diff --git a/dox/dev_guides/upgrade/upgrade.md b/dox/dev_guides/upgrade/upgrade.md index 3b2aa2732f..cbe32b0cc0 100644 --- a/dox/dev_guides/upgrade/upgrade.md +++ b/dox/dev_guides/upgrade/upgrade.md @@ -1131,6 +1131,18 @@ The following obsolete features have been removed: * The package *TestTopOpeDraw* has been removed; * The package *TestTopOpeTools* has been removed. * The packages *QANewModTopOpe*, *QANewBRepNaming* and *QANewDBRepNaming* have been removed as containing obsolete features. +* The following methods of the *IntPolyh_Triangle* class have been removed as unused: + - *CheckCommonEdge* + - *SetEdgeandOrientation* + - *MultipleMiddleRefinement2*. +* The method *IntPolyh_Triangle::TriangleDeflection* has been renamed to *IntPolyh_Triangle::ComputeDeflection*. +* The following methods of the *IntPolyh_MaillageAffinage* class have been removed as unused: + - *LinkEdges2Triangles*; + - *TriangleEdgeContact2*; + - *StartingPointsResearch2*; + - *NextStartingPointsResearch2*; + - *TriangleComparePSP*; + - *StartPointsCalcul*. @subsection upgrade_occt720_correction_of_Offset_API Corrections in BRepOffset API diff --git a/src/IntPolyh/FILES b/src/IntPolyh/FILES index 0d2445e312..be4aa88a66 100755 --- a/src/IntPolyh/FILES +++ b/src/IntPolyh/FILES @@ -1,18 +1,18 @@ IntPolyh_Array.hxx -IntPolyh_ArrayOfCouples.hxx IntPolyh_ArrayOfEdges.hxx IntPolyh_ArrayOfPoints.hxx IntPolyh_ArrayOfSectionLines.hxx -IntPolyh_ArrayOfStartPoints.hxx IntPolyh_ArrayOfTangentZones.hxx IntPolyh_ArrayOfTriangles.hxx IntPolyh_Couple.cxx IntPolyh_Couple.hxx +IntPolyh_CoupleMapHasher.hxx IntPolyh_Edge.cxx IntPolyh_Edge.hxx IntPolyh_Intersection.cxx IntPolyh_Intersection.hxx IntPolyh_Intersection_1.cxx +IntPolyh_ListOfCouples.hxx IntPolyh_MaillageAffinage.cxx IntPolyh_MaillageAffinage.hxx IntPolyh_PMaillageAffinage.hxx @@ -24,4 +24,4 @@ IntPolyh_SeqOfStartPoints.hxx IntPolyh_StartPoint.cxx IntPolyh_StartPoint.hxx IntPolyh_Triangle.cxx -IntPolyh_Triangle.hxx +IntPolyh_Triangle.hxx \ No newline at end of file diff --git a/src/IntPolyh/IntPolyh_ArrayOfStartPoints.hxx b/src/IntPolyh/IntPolyh_ArrayOfStartPoints.hxx deleted file mode 100644 index 917111cfa8..0000000000 --- a/src/IntPolyh/IntPolyh_ArrayOfStartPoints.hxx +++ /dev/null @@ -1,24 +0,0 @@ -// Created on: 2012-11-13 -// Created by: Peter KURNEV -// Copyright (c) 2012-2014 OPEN CASCADE SAS -// -// This file is part of Open CASCADE Technology software library. -// -// This library is free software; you can redistribute it and/or modify it under -// the terms of the GNU Lesser General Public License version 2.1 as published -// by the Free Software Foundation, with special exception defined in the file -// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT -// distribution for complete text of the license and disclaimer of any warranty. -// -// Alternatively, this file may be used under the terms of Open CASCADE -// commercial license or contractual agreement. - -#ifndef IntPolyh_ArrayOfStartPoints_HeaderFile -#define IntPolyh_ArrayOfStartPoints_HeaderFile - -#include -#include - -typedef IntPolyh_Array IntPolyh_ArrayOfStartPoints; - -#endif diff --git a/src/IntPolyh/IntPolyh_Couple.cxx b/src/IntPolyh/IntPolyh_Couple.cxx index e5cefe0af7..cc4f65ecd3 100644 --- a/src/IntPolyh/IntPolyh_Couple.cxx +++ b/src/IntPolyh/IntPolyh_Couple.cxx @@ -16,26 +16,12 @@ #include - #include -IntPolyh_Couple::IntPolyh_Couple() : t1(-1),t2(-1),ia(0),angle(-2.0) { } -IntPolyh_Couple::IntPolyh_Couple(const Standard_Integer a,const Standard_Integer b) : t1(a),t2(b),ia(0),angle(-2.0) { } - -Standard_Integer IntPolyh_Couple::FirstValue() const{ return(t1);} -Standard_Integer IntPolyh_Couple::SecondValue() const{ return(t2);} -Standard_Integer IntPolyh_Couple::AnalyseFlagValue() const{ return(ia);} -Standard_Real IntPolyh_Couple::AngleValue() const{ return(angle);} - -void IntPolyh_Couple::SetCoupleValue(const Standard_Integer a,const Standard_Integer b) -{ t1=a; t2=b; } -void IntPolyh_Couple::SetAnalyseFlag(const Standard_Integer iiaa) { ia=iiaa; } -void IntPolyh_Couple::SetAngleValue(const Standard_Real ang) { angle=ang; } - -void IntPolyh_Couple::Dump(const Standard_Integer i) const{ - printf("\nCouple(%3d) : %5d %5d %3d %5f\n",i,t1,t2,ia,angle); +//======================================================================= +//function : Dump +//purpose : +//======================================================================= +void IntPolyh_Couple::Dump(const Standard_Integer i) const{ + printf("\nCouple(%3d) : %5d %5d %3d %5f\n", i, myIndex1, myIndex2, myAnalyzed, myAngle); } - - - - diff --git a/src/IntPolyh/IntPolyh_Couple.hxx b/src/IntPolyh/IntPolyh_Couple.hxx index d214c33f88..3c49c2c800 100644 --- a/src/IntPolyh/IntPolyh_Couple.hxx +++ b/src/IntPolyh/IntPolyh_Couple.hxx @@ -24,60 +24,92 @@ #include #include - -//! couple of triangles -class IntPolyh_Couple +//! The class represents the couple of indices with additional +//! characteristics such as analyzed flag and an angle.
+//! In IntPolyh_MaillageAffinage algorithm the class is used as a +//! couple of interfering triangles with the intersection angle. +class IntPolyh_Couple { public: DEFINE_STANDARD_ALLOC - - Standard_EXPORT IntPolyh_Couple(); - - Standard_EXPORT IntPolyh_Couple(const Standard_Integer i1, const Standard_Integer i2); - - Standard_EXPORT Standard_Integer FirstValue() const; - - Standard_EXPORT Standard_Integer SecondValue() const; - - Standard_EXPORT Standard_Integer AnalyseFlagValue() const; - - Standard_EXPORT Standard_Real AngleValue() const; - - Standard_EXPORT void SetCoupleValue (const Standard_Integer v, const Standard_Integer w); - - Standard_EXPORT void SetAnalyseFlag (const Standard_Integer v); - - Standard_EXPORT void SetAngleValue (const Standard_Real ang); - + //! Constructor + IntPolyh_Couple() : + myIndex1(-1),myIndex2(-1),myAnalyzed(0),myAngle(-2.0) + {} + //! Constructor + IntPolyh_Couple(const Standard_Integer theTriangle1, + const Standard_Integer theTriangle2, + const Standard_Real theAngle = -2.0) + : + myIndex1(theTriangle1), + myIndex2(theTriangle2), + myAnalyzed(Standard_False), + myAngle(theAngle) + {} + + //! Returns the first index + Standard_Integer FirstValue() const + { + return myIndex1; + } + //! Returns the second index + Standard_Integer SecondValue() const + { + return myIndex2; + } + //! Returns TRUE if the couple has been analyzed + Standard_Boolean IsAnalyzed() const + { + return myAnalyzed; + } + //! Returns the angle + Standard_Real Angle() const + { + return myAngle; + } + //! Sets the triangles + void SetCoupleValue(const Standard_Integer theInd1, + const Standard_Integer theInd2) + { + myIndex1 = theInd1; + myIndex2 = theInd2; + } + //! Sets the analyzed flag + void SetAnalyzed(const Standard_Boolean theAnalyzed) + { + myAnalyzed = theAnalyzed; + } + //! Sets the angle + void SetAngle(const Standard_Real theAngle) + { + myAngle = theAngle; + } + //! Returns true if the Couple is equal to + Standard_Boolean IsEqual (const IntPolyh_Couple& theOther) const + { + return (myIndex1 == theOther.myIndex1 && myIndex2 == theOther.myIndex2) || + (myIndex1 == theOther.myIndex2 && myIndex2 == theOther.myIndex1); + } + // + //! Returns hash code + Standard_Integer HashCode (const Standard_Integer theUpper) const + { + return ::HashCode(myIndex1 + myIndex2, theUpper); + } + // Dump Standard_EXPORT void Dump (const Standard_Integer v) const; - - - protected: - - - - private: - - - Standard_Integer t1; - Standard_Integer t2; - Standard_Integer ia; - Standard_Real angle; - + Standard_Integer myIndex1; + Standard_Integer myIndex2; + Standard_Boolean myAnalyzed; + Standard_Real myAngle; }; - - - - - - #endif // _IntPolyh_Couple_HeaderFile diff --git a/src/IntPolyh/IntPolyh_CoupleMapHasher.hxx b/src/IntPolyh/IntPolyh_CoupleMapHasher.hxx new file mode 100644 index 0000000000..5086d77711 --- /dev/null +++ b/src/IntPolyh/IntPolyh_CoupleMapHasher.hxx @@ -0,0 +1,46 @@ +// Created by: Eugeny MALTCHIKOV +// Copyright (c) 2017 OPEN CASCADE SAS +// +// This file is part of Open CASCADE Technology software library. +// +// This library is free software; you can redistribute it and/or modify it under +// the terms of the GNU Lesser General Public License version 2.1 as published +// by the Free Software Foundation, with special exception defined in the file +// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT +// distribution for complete text of the license and disclaimer of any warranty. +// +// Alternatively, this file may be used under the terms of Open CASCADE +// commercial license or contractual agreement. + +#ifndef _IntPolyh_CoupleMapHasher_HeaderFile +#define _IntPolyh_CoupleMapHasher_HeaderFile + +#include +#include +#include + +class IntPolyh_Couple; + +class IntPolyh_CoupleMapHasher +{ +public: + + static Standard_Integer HashCode(const IntPolyh_Couple& theCouple, + const Standard_Integer Upper) + { + return theCouple.HashCode(Upper); + } + + static Standard_Boolean IsEqual(const IntPolyh_Couple& theCouple1, + const IntPolyh_Couple& theCouple2) + { + return theCouple1.IsEqual(theCouple2); + } + +protected: + +private: + +}; + +#endif // _IntPolyh_CoupleMapHasher_HeaderFile diff --git a/src/IntPolyh/IntPolyh_Edge.cxx b/src/IntPolyh/IntPolyh_Edge.cxx index 7fba60feca..0122125795 100644 --- a/src/IntPolyh/IntPolyh_Edge.cxx +++ b/src/IntPolyh/IntPolyh_Edge.cxx @@ -14,31 +14,14 @@ // Alternatively, this file may be used under the terms of Open CASCADE // commercial license or contractual agreement. - #include - #include -IntPolyh_Edge::IntPolyh_Edge() : p1(-1),p2(-1),t1(-1),t2(-1),ia(-1) { } - -IntPolyh_Edge::IntPolyh_Edge(const Standard_Integer a, const Standard_Integer b, - const Standard_Integer c, const Standard_Integer d) : p1(a),p2(b),t1(c),t2(d),ia(-1) { -} - -Standard_Integer IntPolyh_Edge::FirstPoint() const{ return(p1);} -Standard_Integer IntPolyh_Edge::SecondPoint() const{ return(p2);} -Standard_Integer IntPolyh_Edge::FirstTriangle() const{ return(t1);} -Standard_Integer IntPolyh_Edge::SecondTriangle() const{ return(t2);} -Standard_Integer IntPolyh_Edge::AnalysisFlag() const{ return(ia);} - -void IntPolyh_Edge::SetFirstPoint(const Standard_Integer a) { p1=a; } -void IntPolyh_Edge::SetSecondPoint(const Standard_Integer b) { p2=b; } -void IntPolyh_Edge::SetFirstTriangle(const Standard_Integer c) { t1=c; } -void IntPolyh_Edge::SetSecondTriangle(const Standard_Integer d) { t2=d; } -void IntPolyh_Edge::SetAnalysisFlag(const Standard_Integer e) { ia=e; } +//======================================================================= +//function : Dump +//purpose : +//======================================================================= void IntPolyh_Edge::Dump(const Standard_Integer i) const{ - printf("\nEdge(%3d) : P1:%5d P2:%5d T1:%5d T2:%5d AnalysisFlag:%5d\n",i,p1,p2,t1,t2,ia); + printf("\nEdge(%3d) : P1:%5d P2:%5d T1:%5d T2:%5d\n", + i, myPoint1, myPoint2, myTriangle1, myTriangle2); } - - - diff --git a/src/IntPolyh/IntPolyh_Edge.hxx b/src/IntPolyh/IntPolyh_Edge.hxx index fffed6991e..72e5173c52 100644 --- a/src/IntPolyh/IntPolyh_Edge.hxx +++ b/src/IntPolyh/IntPolyh_Edge.hxx @@ -23,67 +23,81 @@ #include - - -class IntPolyh_Edge +//! The class represents the edge built between the two IntPolyh points.
+//! It is linked to two IntPolyh triangles. +class IntPolyh_Edge { public: DEFINE_STANDARD_ALLOC - - Standard_EXPORT IntPolyh_Edge(); - - Standard_EXPORT IntPolyh_Edge(const Standard_Integer i1, const Standard_Integer i2, const Standard_Integer i3, const Standard_Integer i4); - - Standard_EXPORT Standard_Integer FirstPoint() const; - - Standard_EXPORT Standard_Integer SecondPoint() const; - - Standard_EXPORT Standard_Integer FirstTriangle() const; - - Standard_EXPORT Standard_Integer SecondTriangle() const; - - Standard_EXPORT Standard_Integer AnalysisFlag() const; - - Standard_EXPORT void SetFirstPoint (const Standard_Integer v); - - Standard_EXPORT void SetSecondPoint (const Standard_Integer v); - - Standard_EXPORT void SetFirstTriangle (const Standard_Integer v); - - Standard_EXPORT void SetSecondTriangle (const Standard_Integer v); - - Standard_EXPORT void SetAnalysisFlag (const Standard_Integer v); + //! Constructor + IntPolyh_Edge() : + myPoint1(-1), myPoint2(-1), myTriangle1(-1), myTriangle2(-1) + {} + //! Constructor + IntPolyh_Edge(const Standard_Integer thePoint1, + const Standard_Integer thePoint2, + const Standard_Integer theTriangle1, + const Standard_Integer theTriangle2) + : + myPoint1(thePoint1), + myPoint2(thePoint2), + myTriangle1(theTriangle1), + myTriangle2(theTriangle2) + {} + + //! Returns the first point + Standard_Integer FirstPoint() const + { + return myPoint1; + } + //! Returns the second point + Standard_Integer SecondPoint() const + { + return myPoint2; + } + //! Returns the first triangle + Standard_Integer FirstTriangle() const + { + return myTriangle1; + } + //! Returns the second triangle + Standard_Integer SecondTriangle() const + { + return myTriangle2; + } + //! Sets the first point + void SetFirstPoint (const Standard_Integer thePoint) + { + myPoint1 = thePoint; + } + //! Sets the second point + void SetSecondPoint (const Standard_Integer thePoint) + { + myPoint2 = thePoint; + } + //! Sets the first triangle + void SetFirstTriangle (const Standard_Integer theTriangle) + { + myTriangle1 = theTriangle; + } + //! Sets the second triangle + void SetSecondTriangle (const Standard_Integer theTriangle) + { + myTriangle2 = theTriangle; + } Standard_EXPORT void Dump (const Standard_Integer v) const; - - - protected: - - - - private: - - - Standard_Integer p1; - Standard_Integer p2; - Standard_Integer t1; - Standard_Integer t2; - Standard_Integer ia; - - + Standard_Integer myPoint1; + Standard_Integer myPoint2; + Standard_Integer myTriangle1; + Standard_Integer myTriangle2; }; - - - - - - #endif // _IntPolyh_Edge_HeaderFile diff --git a/src/IntPolyh/IntPolyh_Intersection.cxx b/src/IntPolyh/IntPolyh_Intersection.cxx index 4ebcea801f..0d8802614e 100644 --- a/src/IntPolyh/IntPolyh_Intersection.cxx +++ b/src/IntPolyh/IntPolyh_Intersection.cxx @@ -24,6 +24,8 @@ #include #include #include +#include +#include Standard_Integer MYDISPLAY = 0; Standard_Integer MYPRINT = 0; @@ -229,14 +231,12 @@ Standard_Boolean IntPolyh_Intersection::PerformMaillage theMaillageS->CommonBox(theMaillageS->GetBox(1), theMaillageS->GetBox(2), xx0, yy0, zz0, xx1, yy1, zz1); - theMaillageS->FillArrayOfEdges(1); - theMaillageS->FillArrayOfEdges(2); - theMaillageS->FillArrayOfTriangles(1); theMaillageS->FillArrayOfTriangles(2); - theMaillageS->LinkEdges2Triangles(); - + theMaillageS->FillArrayOfEdges(1); + theMaillageS->FillArrayOfEdges(2); + theMaillageS->TrianglesDeflectionsRefinementBSB(); Standard_Integer FinTTC = theMaillageS->TriangleCompare(); @@ -272,14 +272,12 @@ Standard_Boolean IntPolyh_Intersection::PerformMaillage(IntPolyh_PMaillageAffina theMaillageS->CommonBox(theMaillageS->GetBox(1), theMaillageS->GetBox(2), xx0, yy0, zz0, xx1, yy1, zz1); - theMaillageS->FillArrayOfEdges(1); - theMaillageS->FillArrayOfEdges(2); - theMaillageS->FillArrayOfTriangles(1); theMaillageS->FillArrayOfTriangles(2); - theMaillageS->LinkEdges2Triangles(); - + theMaillageS->FillArrayOfEdges(1); + theMaillageS->FillArrayOfEdges(2); + theMaillageS->TrianglesDeflectionsRefinementBSB(); Standard_Integer FinTTC = theMaillageS->TriangleCompare(); @@ -291,113 +289,63 @@ Standard_Boolean IntPolyh_Intersection::PerformMaillage(IntPolyh_PMaillageAffina theMaillageS->FillArrayOfPnt(2); theMaillageS->CommonBox(theMaillageS->GetBox(1), theMaillageS->GetBox(2), xx0, yy0, zz0, xx1, yy1, zz1); - theMaillageS->FillArrayOfEdges(1); - theMaillageS->FillArrayOfEdges(2); theMaillageS->FillArrayOfTriangles(1); theMaillageS->FillArrayOfTriangles(2); - theMaillageS->LinkEdges2Triangles(); + theMaillageS->FillArrayOfEdges(1); + theMaillageS->FillArrayOfEdges(2); theMaillageS->TrianglesDeflectionsRefinementBSB(); FinTTC = theMaillageS->TriangleCompare(); myZone = Standard_False; theMaillageS->SetEnlargeZone( myZone ); } - /* - // if too many intersections, consider surfaces parallel (eap) - if(FinTTC > 200 && - (FinTTC >= theMaillageS->GetArrayOfTriangles(1).NbTriangles() || - FinTTC >= theMaillageS->GetArrayOfTriangles(2).NbTriangles()) ) { - return Standard_False; - } - */ - return Standard_True; } //======================================================================= //function : MergeCouples -//purpose : This method analyzes arrays to find same couples. If some -// are detected it leaves the couple in only one array +//purpose : This method analyzes the lists to find same couples. +// If some are detected it leaves the couple in only one list // deleting from others. //======================================================================= -void IntPolyh_Intersection::MergeCouples - (IntPolyh_ArrayOfCouples &anArrayFF, - IntPolyh_ArrayOfCouples &anArrayFR, - IntPolyh_ArrayOfCouples &anArrayRF, - IntPolyh_ArrayOfCouples &anArrayRR) const +void IntPolyh_Intersection::MergeCouples(IntPolyh_ListOfCouples &anArrayFF, + IntPolyh_ListOfCouples &anArrayFR, + IntPolyh_ListOfCouples &anArrayRF, + IntPolyh_ListOfCouples &anArrayRR) const { - // Step 1: Sorting arrays. - IntPolyh_ArrayOfCouples *anArrays[4]; - Standard_Integer aNbCouples[4]; - Standard_Integer i; - IntPolyh_ArrayOfCouples *aTmpPtr; - Standard_Integer aTmpNbr; - - anArrays[0] = &anArrayFF; - anArrays[1] = &anArrayFR; - anArrays[2] = &anArrayRF; - anArrays[3] = &anArrayRR; - - for (i = 0; i < 4; i++) - aNbCouples[i] = anArrays[i]->NbItems(); - - Standard_Boolean isChanged = Standard_True; - - while (isChanged) { - isChanged = Standard_False; - - for (i = 0; i < 3; i++) { - if (aNbCouples[i] < aNbCouples[i + 1]) { - aTmpPtr = anArrays[i]; - anArrays[i] = anArrays[i + 1]; - anArrays[i + 1] = aTmpPtr; - aTmpNbr = aNbCouples[i]; - aNbCouples[i] = aNbCouples[i + 1]; - aNbCouples[i + 1] = aTmpNbr; - isChanged = Standard_True; - } - } - } - - // Step 2: Searching for same couples. - Standard_Integer j; - Standard_Integer indC1; - Standard_Integer indC2; - - for (i = 0; i < 3; i++) { - for (j = i + 1; j < 4; j++) { - for (indC1 = 1; indC1 <= aNbCouples[i]; indC1++) { - IntPolyh_Couple &aCouple1 = anArrays[i]->ChangeValue(indC1); - - if (aCouple1.AnalyseFlagValue() == 1) - continue; - - for (indC2 = 1; indC2 <= aNbCouples[j]; indC2++) { - IntPolyh_Couple &aCouple2 = anArrays[j]->ChangeValue(indC2); - - if (aCouple2.AnalyseFlagValue() == 1) - continue; - - if (aCouple1.FirstValue() == aCouple2.FirstValue() && - aCouple1.SecondValue() == aCouple2.SecondValue()) { - aCouple2.SetAnalyseFlag(1); - } - } + // Fence map to remove from the lists the duplicating elements. + NCollection_Map aFenceMap; + // + IntPolyh_ListOfCouples* pLists[4] = {&anArrayFF, &anArrayFR, &anArrayRF, &anArrayRR}; + for (Standard_Integer i = 0; i < 4; ++i) { + IntPolyh_ListIteratorOfListOfCouples aIt(*pLists[i]); + for (; aIt.More();) { + if (!aFenceMap.Add(aIt.Value())) { + pLists[i]->Remove(aIt); + continue; } + aIt.Next(); } } } -// Modified by skv - Thu Sep 25 18:07:42 2003 OCC567 End +//======================================================================= +//function : PerformStd +//purpose : +//======================================================================= Standard_Boolean IntPolyh_Intersection::PerformStd(IntPolyh_PMaillageAffinage& MaillageS, Standard_Integer& NbCouples) { Standard_Boolean isdone = PerformMaillage(MaillageS); - NbCouples = (isdone) ? (MaillageS->GetArrayOfCouples().NbItems()) : 0; + NbCouples = (isdone) ? (MaillageS->GetCouples().Extent()) : 0; return isdone; } +//======================================================================= +//function : PerformAdv +//purpose : +//======================================================================= Standard_Boolean IntPolyh_Intersection::PerformAdv(IntPolyh_PMaillageAffinage& MaillageFF, IntPolyh_PMaillageAffinage& MaillageFR, IntPolyh_PMaillageAffinage& MaillageRF, @@ -414,14 +362,14 @@ Standard_Boolean IntPolyh_Intersection::PerformAdv(IntPolyh_PMaillageAffinage& M isdone = Standard_False; if(isdone) { - NbCouples = MaillageFF->GetArrayOfCouples().NbItems() + - MaillageFR->GetArrayOfCouples().NbItems() + - MaillageRF->GetArrayOfCouples().NbItems() + - MaillageRR->GetArrayOfCouples().NbItems(); + NbCouples = MaillageFF->GetCouples().Extent() + + MaillageFR->GetCouples().Extent() + + MaillageRF->GetCouples().Extent() + + MaillageRR->GetCouples().Extent(); if(NbCouples > 0) - MergeCouples(MaillageFF->GetArrayOfCouples(),MaillageFR->GetArrayOfCouples(), - MaillageRF->GetArrayOfCouples(),MaillageRR->GetArrayOfCouples()); + MergeCouples(MaillageFF->GetCouples(),MaillageFR->GetCouples(), + MaillageRF->GetCouples(),MaillageRR->GetCouples()); } return isdone; } diff --git a/src/IntPolyh/IntPolyh_Intersection.hxx b/src/IntPolyh/IntPolyh_Intersection.hxx index 4ec0e6be8b..5103fb190d 100644 --- a/src/IntPolyh/IntPolyh_Intersection.hxx +++ b/src/IntPolyh/IntPolyh_Intersection.hxx @@ -28,7 +28,7 @@ #include #include #include -#include +#include class Adaptor3d_HSurface; @@ -109,7 +109,7 @@ private: //! This method analyzes arrays to find same couples. If some //! are detected it leaves the couple in only one array //! deleting from others. - Standard_EXPORT void MergeCouples (IntPolyh_ArrayOfCouples& anArrayFF, IntPolyh_ArrayOfCouples& anArrayFR, IntPolyh_ArrayOfCouples& anArrayRF, IntPolyh_ArrayOfCouples& anArrayRR) const; + Standard_EXPORT void MergeCouples (IntPolyh_ListOfCouples& anArrayFF, IntPolyh_ListOfCouples& anArrayFR, IntPolyh_ListOfCouples& anArrayRF, IntPolyh_ListOfCouples& anArrayRR) const; //! Process default interference Standard_EXPORT Standard_Boolean PerformStd (IntPolyh_PMaillageAffinage& MaillageS, Standard_Integer& NbCouples); diff --git a/src/IntPolyh/IntPolyh_Intersection_1.cxx b/src/IntPolyh/IntPolyh_Intersection_1.cxx index 639ae60f95..512754a372 100644 --- a/src/IntPolyh/IntPolyh_Intersection_1.cxx +++ b/src/IntPolyh/IntPolyh_Intersection_1.cxx @@ -15,7 +15,7 @@ #include -#include +#include #include #include #include @@ -153,34 +153,26 @@ Standard_Boolean IntPolyh_Intersection::PerformMaillage(const Standard_Boolean i theMaillageS->CommonBox(theMaillageS->GetBox(1), theMaillageS->GetBox(2), xx0, yy0, zz0, xx1, yy1, zz1); + theMaillageS->FillArrayOfTriangles(1); + theMaillageS->FillArrayOfTriangles(2); + theMaillageS->FillArrayOfEdges(1); theMaillageS->FillArrayOfEdges(2); - theMaillageS->FillArrayOfTriangles(1); - theMaillageS->FillArrayOfTriangles(2); - - theMaillageS->LinkEdges2Triangles(); - theMaillageS->TrianglesDeflectionsRefinementBSB(); Standard_Integer FinTTC = theMaillageS->TriangleCompare(); // if too many intersections, consider surfaces parallel (eap) -/* - if(FinTTC > 200 && - (FinTTC >= theMaillageS->GetArrayOfTriangles(1).NbTriangles() || - FinTTC >= theMaillageS->GetArrayOfTriangles(2).NbTriangles()) ) { - return Standard_False; - } -*/ -//IFV test for parallel surf + // test for parallel surf if(FinTTC > 200) { const Standard_Real eps = .996; //~ cos of 5deg. - IntPolyh_ArrayOfCouples& Couples = theMaillageS->GetArrayOfCouples(); + IntPolyh_ListOfCouples& Couples = theMaillageS->GetCouples(); - Standard_Integer i, npara = 0; - for(i = 0; i < FinTTC; ++i) { - Standard_Real cosa = Abs(Couples[i].AngleValue()); + Standard_Integer npara = 0; + IntPolyh_ListIteratorOfListOfCouples aIt(Couples); + for(; aIt.More(); aIt.Next()) { + Standard_Real cosa = Abs(aIt.Value().Angle()); if(cosa > eps) ++npara; } if(npara >= theMaillageS->GetArrayOfTriangles(1).NbItems() || @@ -214,14 +206,13 @@ Standard_Boolean IntPolyh_Intersection::PerformMaillage(const TColStd_Array1OfRe Standard_Real xx0,yy0,zz0,xx1,yy1,zz1; theMaillageS->CommonBox(theMaillageS->GetBox(1), theMaillageS->GetBox(2), xx0, yy0, zz0, xx1, yy1, zz1); - theMaillageS->FillArrayOfEdges(1); - theMaillageS->FillArrayOfEdges(2); theMaillageS->FillArrayOfTriangles(1); theMaillageS->FillArrayOfTriangles(2); - - theMaillageS->LinkEdges2Triangles(); - + + theMaillageS->FillArrayOfEdges(1); + theMaillageS->FillArrayOfEdges(2); + theMaillageS->TrianglesDeflectionsRefinementBSB(); Standard_Integer FinTTC = theMaillageS->TriangleCompare(); @@ -233,11 +224,10 @@ Standard_Boolean IntPolyh_Intersection::PerformMaillage(const TColStd_Array1OfRe theMaillageS->FillArrayOfPnt(2); theMaillageS->CommonBox(theMaillageS->GetBox(1), theMaillageS->GetBox(2), xx0, yy0, zz0, xx1, yy1, zz1); - theMaillageS->FillArrayOfEdges(1); - theMaillageS->FillArrayOfEdges(2); theMaillageS->FillArrayOfTriangles(1); theMaillageS->FillArrayOfTriangles(2); - theMaillageS->LinkEdges2Triangles(); + theMaillageS->FillArrayOfEdges(1); + theMaillageS->FillArrayOfEdges(2); theMaillageS->TrianglesDeflectionsRefinementBSB(); FinTTC = theMaillageS->TriangleCompare(); myZone = Standard_False; @@ -245,21 +235,15 @@ Standard_Boolean IntPolyh_Intersection::PerformMaillage(const TColStd_Array1OfRe } // if too many intersections, consider surfaces parallel (eap) -/* - if(FinTTC > 200 && - (FinTTC >= theMaillageS->GetArrayOfTriangles(1).NbTriangles() || - FinTTC >= theMaillageS->GetArrayOfTriangles(2).NbTriangles()) ) { - return Standard_False; - } -*/ //IFV test for parallel surf if(FinTTC > 200) { const Standard_Real eps = .996; //~ cos of 5deg. - IntPolyh_ArrayOfCouples& Couples = theMaillageS->GetArrayOfCouples(); + IntPolyh_ListOfCouples& Couples = theMaillageS->GetCouples(); - Standard_Integer i, npara = 0; - for(i = 0; i < FinTTC; ++i) { - Standard_Real cosa = Abs(Couples[i].AngleValue()); + Standard_Integer npara = 0; + IntPolyh_ListIteratorOfListOfCouples aIt(Couples); + for(; aIt.More(); aIt.Next()) { + Standard_Real cosa = Abs(aIt.Value().Angle()); if(cosa > eps) ++npara; } if(npara >= theMaillageS->GetArrayOfTriangles(1).NbItems() || @@ -303,14 +287,14 @@ Standard_Boolean IntPolyh_Intersection::PerformAdv(const TColStd_Array1OfReal& U isdone = Standard_False; if(isdone) { - NbCouples = MaillageFF->GetArrayOfCouples().NbItems() + - MaillageFR->GetArrayOfCouples().NbItems() + - MaillageRF->GetArrayOfCouples().NbItems() + - MaillageRR->GetArrayOfCouples().NbItems(); + NbCouples = MaillageFF->GetCouples().Extent() + + MaillageFR->GetCouples().Extent() + + MaillageRF->GetCouples().Extent() + + MaillageRR->GetCouples().Extent(); if(NbCouples > 0) - MergeCouples(MaillageFF->GetArrayOfCouples(),MaillageFR->GetArrayOfCouples(), - MaillageRF->GetArrayOfCouples(),MaillageRR->GetArrayOfCouples()); + MergeCouples(MaillageFF->GetCouples(),MaillageFR->GetCouples(), + MaillageRF->GetCouples(),MaillageRR->GetCouples()); } return isdone; } @@ -328,6 +312,6 @@ Standard_Boolean IntPolyh_Intersection::PerformStd(const TColStd_Array1OfReal& U { Standard_Boolean isdone = PerformMaillage(Upars1, Vpars1, Upars2, Vpars2, MaillageS); - NbCouples = (isdone) ? (MaillageS->GetArrayOfCouples().NbItems()) : 0; + NbCouples = (isdone) ? (MaillageS->GetCouples().Extent()) : 0; return isdone; } diff --git a/src/IntPolyh/IntPolyh_ArrayOfCouples.hxx b/src/IntPolyh/IntPolyh_ListOfCouples.hxx similarity index 73% rename from src/IntPolyh/IntPolyh_ArrayOfCouples.hxx rename to src/IntPolyh/IntPolyh_ListOfCouples.hxx index 8373cbce74..0eee2a6ca1 100644 --- a/src/IntPolyh/IntPolyh_ArrayOfCouples.hxx +++ b/src/IntPolyh/IntPolyh_ListOfCouples.hxx @@ -13,12 +13,13 @@ // Alternatively, this file may be used under the terms of Open CASCADE // commercial license or contractual agreement. -#ifndef IntPolyh_ArrayOfCouples_HeaderFile -#define IntPolyh_ArrayOfCouples_HeaderFile +#ifndef IntPolyh_ListOfCouples_HeaderFile +#define IntPolyh_ListOfCouples_HeaderFile -#include +#include #include -typedef IntPolyh_Array IntPolyh_ArrayOfCouples; +typedef NCollection_List IntPolyh_ListOfCouples; +typedef IntPolyh_ListOfCouples::Iterator IntPolyh_ListIteratorOfListOfCouples; #endif diff --git a/src/IntPolyh/IntPolyh_MaillageAffinage.cxx b/src/IntPolyh/IntPolyh_MaillageAffinage.cxx index 5f851793aa..9d18c37f12 100644 --- a/src/IntPolyh/IntPolyh_MaillageAffinage.cxx +++ b/src/IntPolyh/IntPolyh_MaillageAffinage.cxx @@ -30,7 +30,7 @@ #include #include #include -#include +#include #include #include #include @@ -39,7 +39,20 @@ #include #include #include +#include +#include #include +#include +#include +#include +#include + +typedef NCollection_Array1 IntPolyh_ArrayOfInteger; +typedef NCollection_IndexedDataMap + IntPolyh_IndexedDataMapOfIntegerArrayOfInteger; + static Standard_Real MyTolerance=10.0e-7; static Standard_Real MyConfusionPrecision=10.0e-12; @@ -73,46 +86,33 @@ static static void CalculPtsInterTriEdgeCoplanaires(const Standard_Integer TriSurfID, const IntPolyh_Point &NormaleTri, + const IntPolyh_Triangle &Tri1, + const IntPolyh_Triangle &Tri2, const IntPolyh_Point &PE1, const IntPolyh_Point &PE2, const IntPolyh_Point &Edge, + const Standard_Integer EdgeIndex, const IntPolyh_Point &PT1, const IntPolyh_Point &PT2, const IntPolyh_Point &Cote, const Standard_Integer CoteIndex, IntPolyh_StartPoint &SP1, IntPolyh_StartPoint &SP2, - Standard_Integer &NbPoints); + Standard_Integer &NbPoints); static - void CalculPtsInterTriEdgeCoplanaires2(const Standard_Integer TriSurfID, - const IntPolyh_Point &NormaleTri, - const IntPolyh_Triangle &Tri1, - const IntPolyh_Triangle &Tri2, - const IntPolyh_Point &PE1, - const IntPolyh_Point &PE2, - const IntPolyh_Point &Edge, - const Standard_Integer EdgeIndex, - const IntPolyh_Point &PT1, - const IntPolyh_Point &PT2, - const IntPolyh_Point &Cote, - const Standard_Integer CoteIndex, - IntPolyh_StartPoint &SP1, - IntPolyh_StartPoint &SP2, - Standard_Integer &NbPoints); -static - Standard_Integer CheckCoupleAndGetAngle(const Standard_Integer T1, + Standard_Boolean CheckCoupleAndGetAngle(const Standard_Integer T1, const Standard_Integer T2, Standard_Real& Angle, - IntPolyh_ArrayOfCouples &TTrianglesContacts); + IntPolyh_ListOfCouples &TTrianglesContacts); static - Standard_Integer CheckCoupleAndGetAngle2(const Standard_Integer T1, + Standard_Boolean CheckCoupleAndGetAngle2(const Standard_Integer T1, const Standard_Integer T2, const Standard_Integer T11, const Standard_Integer T22, - Standard_Integer &CT11, - Standard_Integer &CT22, + IntPolyh_ListIteratorOfListOfCouples& theItCT11, + IntPolyh_ListIteratorOfListOfCouples& theItCT22, Standard_Real & Angle, - IntPolyh_ArrayOfCouples &TTrianglesContacts); + IntPolyh_ListOfCouples &TTrianglesContacts); static Standard_Integer CheckNextStartPoint(IntPolyh_SectionLine & SectionLine, IntPolyh_ArrayOfTangentZones & TTangentZones, @@ -137,7 +137,95 @@ static Standard_Real &u1, Standard_Real &v0, Standard_Real &v1); - + +//======================================================================= +//class : IntPolyh_BoxBndTreeSelector +//purpose : Select interfering bounding boxes +//======================================================================= +typedef NCollection_UBTree IntPolyh_BoxBndTree; +class IntPolyh_BoxBndTreeSelector : public IntPolyh_BoxBndTree::Selector { + public: + IntPolyh_BoxBndTreeSelector(const Bnd_Box& theBox) : myBox(theBox) {} + // + virtual Standard_Boolean Reject(const Bnd_Box& theOther) const + { + return myBox.IsOut(theOther); + } + // + virtual Standard_Boolean Accept(const Standard_Integer &theInd) + { + myIndices.Append(theInd); + return Standard_True; + } + // + const TColStd_ListOfInteger& Indices() const + { + return myIndices; + } + private: + Bnd_Box myBox; + TColStd_ListOfInteger myIndices; +}; + +//======================================================================= +//function : GetInterferingTriangles +//purpose : Returns indices of the triangles with interfering bounding boxes +//======================================================================= +static + void GetInterferingTriangles(IntPolyh_ArrayOfTriangles& theTriangles1, + const IntPolyh_ArrayOfPoints& thePoints1, + IntPolyh_ArrayOfTriangles& theTriangles2, + const IntPolyh_ArrayOfPoints& thePoints2, + IntPolyh_IndexedDataMapOfIntegerArrayOfInteger& theCouples) +{ + // To find the triangles with interfering bounding boxes + // use the algorithm of unbalanced binary tree of overlapping bounding boxes + IntPolyh_BoxBndTree aBBTree; + NCollection_UBTreeFiller aTreeFiller(aBBTree); + // 1. Fill the tree with the boxes of the triangles from second surface + Standard_Integer i, aNbT2 = theTriangles2.NbItems(); + for (i = 0; i < aNbT2; ++i) { + IntPolyh_Triangle& aT = theTriangles2[i]; + if (!aT.IsIntersectionPossible() || aT.IsDegenerated()) { + continue; + } + // + const Bnd_Box& aBox = aT.BoundingBox(thePoints2); + aTreeFiller.Add(i, aBox); + } + // + // 2. Shake the tree filler + aTreeFiller.Fill(); + // + // 3. Find boxes interfering with the first triangles + Standard_Integer aNbT1 = theTriangles1.NbItems(); + for (i = 0; i < aNbT1; ++i) { + IntPolyh_Triangle& aT = theTriangles1[i]; + if (!aT.IsIntersectionPossible() || aT.IsDegenerated()) { + continue; + } + // + const Bnd_Box& aBox = aT.BoundingBox(thePoints1); + // + IntPolyh_BoxBndTreeSelector aSelector(aBox); + if (!aBBTree.Select(aSelector)) { + continue; + } + // + const TColStd_ListOfInteger& aLI = aSelector.Indices(); + // Sort the indices + IntPolyh_ArrayOfInteger anArr(1, aLI.Extent()); + TColStd_ListIteratorOfListOfInteger aItLI(aLI); + for (Standard_Integer j = 1; aItLI.More(); aItLI.Next(), ++j) { + anArr(j) = aItLI.Value(); + } + // + std::sort(anArr.begin(), anArr.end()); + // + theCouples.Add(i, anArr); + } +} + //======================================================================= //function : IntPolyh_MaillageAffinage //purpose : @@ -589,6 +677,7 @@ void IntPolyh_MaillageAffinage::FillArrayOfEdges { IntPolyh_ArrayOfEdges &TEdges=(SurfID==1)? TEdges1:TEdges2; + IntPolyh_ArrayOfTriangles &TTriangles=(SurfID==1)? TTriangles1:TTriangles2; Standard_Integer NbSamplesU=(SurfID==1)? NbSamplesU1:NbSamplesU2; Standard_Integer NbSamplesV=(SurfID==1)? NbSamplesV1:NbSamplesV2; @@ -603,20 +692,22 @@ void IntPolyh_MaillageAffinage::FillArrayOfEdges //maillage u0 v0 TEdges[CpteurTabEdges].SetFirstPoint(0); // U V TEdges[CpteurTabEdges].SetSecondPoint(1); // U V+1 - // TEdges[CpteurTabEdges].SetFirstTriangle(-1); TEdges[CpteurTabEdges].SetSecondTriangle(0); + TTriangles[0].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges); CpteurTabEdges++; - + TEdges[CpteurTabEdges].SetFirstPoint(0); // U V TEdges[CpteurTabEdges].SetSecondPoint(NbSamplesV); // U+1 V - TEdges[CpteurTabEdges].SetFirstTriangle(0); - TEdges[CpteurTabEdges].SetSecondTriangle(1); + TEdges[CpteurTabEdges].SetFirstTriangle(1); + TTriangles[1].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges); CpteurTabEdges++; TEdges[CpteurTabEdges].SetFirstPoint(0); // U V TEdges[CpteurTabEdges].SetSecondPoint(NbSamplesV+1); // U+1 V+1 - TEdges[CpteurTabEdges].SetFirstTriangle(1); - // TEdges[CpteurTabEdges].SetSecondTriangle(-1); + TEdges[CpteurTabEdges].SetFirstTriangle(0); + TTriangles[0].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges); + TEdges[CpteurTabEdges].SetSecondTriangle(1); + TTriangles[1].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges); CpteurTabEdges++; //maillage surU=u0 @@ -627,18 +718,23 @@ void IntPolyh_MaillageAffinage::FillArrayOfEdges TEdges[CpteurTabEdges].SetSecondPoint(PntInit+1); // U V+1 // TEdges[CpteurTabEdges].SetFirstTriangle(-1); TEdges[CpteurTabEdges].SetSecondTriangle(BoucleMeshV*2); + TTriangles[BoucleMeshV*2].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges); CpteurTabEdges++; TEdges[CpteurTabEdges].SetFirstPoint(PntInit); // U V TEdges[CpteurTabEdges].SetSecondPoint(PntInit+NbSamplesV+1); // U+1 V+1 TEdges[CpteurTabEdges].SetFirstTriangle(BoucleMeshV*2); + TTriangles[BoucleMeshV*2].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges); TEdges[CpteurTabEdges].SetSecondTriangle(BoucleMeshV*2+1); + TTriangles[BoucleMeshV*2+1].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges); CpteurTabEdges++; TEdges[CpteurTabEdges].SetFirstPoint(PntInit); // U V TEdges[CpteurTabEdges].SetSecondPoint(PntInit+NbSamplesV); // U+1 V TEdges[CpteurTabEdges].SetFirstTriangle(BoucleMeshV*2+1); + TTriangles[BoucleMeshV*2+1].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges); TEdges[CpteurTabEdges].SetSecondTriangle(BoucleMeshV*2-2); + TTriangles[BoucleMeshV*2-2].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges); CpteurTabEdges++; PntInit++; } @@ -649,19 +745,23 @@ void IntPolyh_MaillageAffinage::FillArrayOfEdges TEdges[CpteurTabEdges].SetFirstPoint(PntInit); // U V TEdges[CpteurTabEdges].SetSecondPoint(PntInit+1); // U V+1 TEdges[CpteurTabEdges].SetFirstTriangle((BoucleMeshV-1)*(NbSamplesV-1)*2+1); + TTriangles[(BoucleMeshV-1)*(NbSamplesV-1)*2+1].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges); TEdges[CpteurTabEdges].SetSecondTriangle(BoucleMeshV*(NbSamplesV-1)*2); + TTriangles[BoucleMeshV*(NbSamplesV-1)*2].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges); CpteurTabEdges++; TEdges[CpteurTabEdges].SetFirstPoint(PntInit); // U V TEdges[CpteurTabEdges].SetSecondPoint(PntInit+NbSamplesV+1); // U+1 V+1 TEdges[CpteurTabEdges].SetFirstTriangle(BoucleMeshV*(NbSamplesV-1)*2); + TTriangles[BoucleMeshV*(NbSamplesV-1)*2].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges); TEdges[CpteurTabEdges].SetSecondTriangle(BoucleMeshV*(NbSamplesV-1)*2+1); + TTriangles[BoucleMeshV*(NbSamplesV-1)*2+1].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges); CpteurTabEdges++; TEdges[CpteurTabEdges].SetFirstPoint(PntInit); // U V TEdges[CpteurTabEdges].SetSecondPoint(PntInit+NbSamplesV); // U+1 V TEdges[CpteurTabEdges].SetFirstTriangle(BoucleMeshV*(NbSamplesV-1)*2+1); - // TEdges[CpteurTabEdges].SetSecondTriangle(-1); + TTriangles[BoucleMeshV*(NbSamplesV-1)*2+1].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges); CpteurTabEdges++; PntInit+=NbSamplesV; } @@ -673,19 +773,25 @@ void IntPolyh_MaillageAffinage::FillArrayOfEdges TEdges[CpteurTabEdges].SetFirstPoint(PntInit); // U V TEdges[CpteurTabEdges].SetSecondPoint(PntInit+1); // U V+1 TEdges[CpteurTabEdges].SetFirstTriangle((NbSamplesV-1)*2*(BoucleMeshU-1)+BoucleMeshV*2+1); + TTriangles[(NbSamplesV-1)*2*(BoucleMeshU-1)+BoucleMeshV*2+1].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges); TEdges[CpteurTabEdges].SetSecondTriangle((NbSamplesV-1)*2*BoucleMeshU+BoucleMeshV*2); + TTriangles[(NbSamplesV-1)*2*BoucleMeshU+BoucleMeshV*2].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges); CpteurTabEdges++; TEdges[CpteurTabEdges].SetFirstPoint(PntInit); // U V TEdges[CpteurTabEdges].SetSecondPoint(PntInit+NbSamplesV+1); // U+1 V+1 TEdges[CpteurTabEdges].SetFirstTriangle((NbSamplesV-1)*2*BoucleMeshU+BoucleMeshV*2); + TTriangles[(NbSamplesV-1)*2*BoucleMeshU+BoucleMeshV*2].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges); TEdges[CpteurTabEdges].SetSecondTriangle((NbSamplesV-1)*2*BoucleMeshU+BoucleMeshV*2+1); + TTriangles[(NbSamplesV-1)*2*BoucleMeshU+BoucleMeshV*2+1].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges); CpteurTabEdges++; TEdges[CpteurTabEdges].SetFirstPoint(PntInit); // U V TEdges[CpteurTabEdges].SetSecondPoint(PntInit+NbSamplesV); // U+1 V TEdges[CpteurTabEdges].SetFirstTriangle((NbSamplesV-1)*2*BoucleMeshU+BoucleMeshV*2+1); + TTriangles[(NbSamplesV-1)*2*BoucleMeshU+BoucleMeshV*2+1].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges); TEdges[CpteurTabEdges].SetSecondTriangle((NbSamplesV-1)*2*BoucleMeshU+BoucleMeshV*2-2); + TTriangles[(NbSamplesV-1)*2*BoucleMeshU+BoucleMeshV*2-2].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges); CpteurTabEdges++; PntInit++;//Pass to the next point } @@ -699,7 +805,7 @@ void IntPolyh_MaillageAffinage::FillArrayOfEdges TEdges[CpteurTabEdges].SetFirstPoint(PntInit); //U=u1 V TEdges[CpteurTabEdges].SetSecondPoint(PntInit+1); //U=u1 V+1 TEdges[CpteurTabEdges].SetFirstTriangle((NbSamplesU-2)*(NbSamplesV-1)*2+BoucleMeshV*2+1); - // TEdges[CpteurTabEdges].SetSecondTriangle(-1); + TTriangles[(NbSamplesU-2)*(NbSamplesV-1)*2+BoucleMeshV*2+1].SetEdgeAndOrientation(TEdges[CpteurTabEdges], CpteurTabEdges); CpteurTabEdges++; PntInit++; } @@ -708,8 +814,8 @@ void IntPolyh_MaillageAffinage::FillArrayOfEdges for(BoucleMeshV=0; BoucleMeshV FlecheMax) + FlecheMax = Fleche; + if (Fleche < FlecheMin) + FlecheMin = Fleche; + } +} +//======================================================================= +//function : TrianglesDeflectionsRefinement +//purpose : Refinement of the triangles depending on the deflection +//======================================================================= +static + void TrianglesDeflectionsRefinement(const Handle(Adaptor3d_HSurface)& theS1, + IntPolyh_ArrayOfTriangles& theTriangles1, + IntPolyh_ArrayOfEdges& theEdges1, + IntPolyh_ArrayOfPoints& thePoints1, + const Standard_Real theFlecheCritique1, + const Handle(Adaptor3d_HSurface)& theS2, + IntPolyh_ArrayOfTriangles& theTriangles2, + IntPolyh_ArrayOfEdges& theEdges2, + IntPolyh_ArrayOfPoints& thePoints2, + const Standard_Real theFlecheCritique2) +{ + // Find the intersecting triangles + IntPolyh_IndexedDataMapOfIntegerArrayOfInteger aDMILI; + GetInterferingTriangles(theTriangles1, thePoints1, theTriangles2, thePoints2, aDMILI); + // + // Interfering triangles of second surface + TColStd_MapOfInteger aMIntS2; + // Since the number of the triangles may change during refinement, + // save the number of triangles before refinement + Standard_Integer FinTT1 = theTriangles1.NbItems(); + Standard_Integer FinTT2 = theTriangles2.NbItems(); + // + // Analyze interfering triangles + for (Standard_Integer i_S1 = 0; i_S1 < FinTT1; i_S1++) { + IntPolyh_Triangle& aTriangle1 = theTriangles1[i_S1]; + if (!aTriangle1.IsIntersectionPossible()) { + continue; } - else{ - Triangle.TriangleDeflection(MaSurface, TPoints); - Standard_Real Fleche=Triangle.GetFleche(); + // + const IntPolyh_ArrayOfInteger *pLI = aDMILI.Seek(i_S1); + if (!pLI || !pLI->Length()) { + // Mark non-interfering triangles of S1 to avoid their repeated usage + aTriangle1.SetIntersectionPossible(Standard_False); + continue; + } + // + if (aTriangle1.Deflection() > theFlecheCritique1) { + aTriangle1.MiddleRefinement(i_S1, theS1, thePoints1, theTriangles1, theEdges1); + } + // + IntPolyh_ArrayOfInteger::Iterator Iter(*pLI); + for (; Iter.More(); Iter.Next()) { + Standard_Integer i_S2 = Iter.Value(); + if (aMIntS2.Add(i_S2)) { + IntPolyh_Triangle & aTriangle2 = theTriangles2[i_S2]; + if (aTriangle2.Deflection() > theFlecheCritique2) { + // Refinement of the larger triangles + aTriangle2.MiddleRefinement(i_S2, theS2, thePoints2, theTriangles2, theEdges2); + } + } + } + } + // + // Mark non-interfering triangles of S2 to avoid their repeated usage + if (aMIntS2.Extent() < FinTT2) { + for (Standard_Integer i_S2 = 0; i_S2 < FinTT2; i_S2++) { + if (!aMIntS2.Contains(i_S2)) { + theTriangles2[i_S2].SetIntersectionPossible(Standard_False); + } + } + } +} +//======================================================================= +//function : LargeTrianglesDeflectionsRefinement +//purpose : Refinement of the large triangles in case one surface is +// much smaller then the other. +//======================================================================= +static + void LargeTrianglesDeflectionsRefinement(const Handle(Adaptor3d_HSurface)& theS, + IntPolyh_ArrayOfTriangles& theTriangles, + IntPolyh_ArrayOfEdges& theEdges, + IntPolyh_ArrayOfPoints& thePoints, + const Bnd_Box& theOppositeBox) +{ + // Find all triangles of the bigger surface with bounding boxes + // overlapping the bounding box the other surface + TColStd_ListOfInteger aLIT; + Standard_Integer i, aNbT = theTriangles.NbItems(); + for (i = 0; i < aNbT; ++i) { + IntPolyh_Triangle& aTriangle = theTriangles[i]; + if (!aTriangle.IsIntersectionPossible() || aTriangle.IsDegenerated()) { + continue; + } + // + const Bnd_Box& aBox = aTriangle.BoundingBox(thePoints); + if (aBox.IsVoid()) { + continue; + } + // + if (aBox.IsOut(theOppositeBox)) { + aTriangle.SetIntersectionPossible(Standard_False); + continue; + } + // + aLIT.Append(i); + } + // + if (aLIT.IsEmpty()) { + return; + } + // + // One surface is very small relatively to the other. + // The criterion of refining for large surface depends on the size of + // the bounding box of the other - since the criterion should be minimized, + // the smallest side of the bounding box is taken + Standard_Real x0, y0, z0, x1, y1, z1; + theOppositeBox.Get(x0, y0, z0, x1, y1, z1); + Standard_Real dx = Abs(x1 - x0); + Standard_Real dy = Abs(y1 - y0); + Standard_Real diag = Abs(z1 - z0); + Standard_Real dd = (dx > dy) ? dy : dx; + if (diag > dd) diag = dd; - if (Fleche > FlecheMax) - FlecheMax=Fleche; - if (Fleche < FlecheMin) - FlecheMin=Fleche; + // calculation of the criterion of refining + Standard_Real CritereAffinage = 0.0; + Standard_Real DiagPonderation = 0.5; + CritereAffinage = diag*DiagPonderation; + // + // The deflection of the greater is compared to the size of the smaller + TColStd_ListIteratorOfListOfInteger Iter(aLIT); + for (; Iter.More(); Iter.Next()) { + i = Iter.Value(); + IntPolyh_Triangle & aTriangle = theTriangles[i]; + if (aTriangle.Deflection() > CritereAffinage) { + aTriangle.MultipleMiddleRefinement(CritereAffinage, theOppositeBox, i, + theS, thePoints, theTriangles, theEdges); + } + else { + aTriangle.MiddleRefinement(i, theS, thePoints, theTriangles, theEdges); } } } //======================================================================= //function : TrianglesDeflectionsRefinementBSB -//purpose : Refine both surfaces using BoundSortBox as -- -// rejection. The criterions used to refine a -- -// triangle are: The deflection The size of the -- -// bounding boxes (one surface may be very small -// compared to the other) +//purpose : Refine both surfaces using UBTree as rejection. +// The criterion used to refine a triangle are: +// - The deflection; +// - The size of the - bounding boxes (one surface may be +// very small compared to the other). //======================================================================= -void IntPolyh_MaillageAffinage::TrianglesDeflectionsRefinementBSB() +void IntPolyh_MaillageAffinage::TrianglesDeflectionsRefinementBSB() { - const Standard_Integer FinTT1 = TTriangles1.NbItems(); - const Standard_Integer FinTT2 = TTriangles2.NbItems(); - + // To estimate a surface in general it can be interesting + // to calculate all deflections ComputeDeflections(1); - // To estimate a surface in general it can be interesting - //to calculate all deflections - //-- Check deflection at output - + // Check deflection at output Standard_Real FlecheCritique1; - if(FlecheMin1>FlecheMax1) { - return; - } - else {//fleche min + (flechemax-flechemin) * 80/100 - FlecheCritique1 = FlecheMin1*0.2+FlecheMax1*0.8; - } - - ComputeDeflections(2); - //-- Check arrows at output - - Standard_Real FlecheCritique2; - if(FlecheMin2>FlecheMax2) { - + if (FlecheMin1 > FlecheMax1) { return; } - else {//fleche min + (flechemax-flechemin) * 80/100 - FlecheCritique2 = FlecheMin2*0.2+FlecheMax2*0.8; + else { + // fleche min + (flechemax-flechemin) * 80/100 + FlecheCritique1 = FlecheMin1*0.2 + FlecheMax1*0.8; } - - //Bounding boxes - Bnd_BoundSortBox BndBSB; - Standard_Real diag1,diag2; - Standard_Real x0,y0,z0,x1,y1,z1; - - //The greatest of two bounding boxes created in FillArrayOfPoints is found. - //Then this value is weighted depending on the discretization - //(NbSamplesU and NbSamplesV) - MyBox1.Get(x0,y0,z0,x1,y1,z1); - x0-=x1; y0-=y1; z0-=z1; - diag1=x0*x0+y0*y0+z0*z0; - const Standard_Real NbSamplesUV1=Standard_Real(NbSamplesU1) * Standard_Real(NbSamplesV1); - diag1/=NbSamplesUV1; - MyBox2.Get(x0,y0,z0,x1,y1,z1); - x0-=x1; y0-=y1; z0-=z1; - diag2=x0*x0+y0*y0+z0*z0; - const Standard_Real NbSamplesUV2=Standard_Real(NbSamplesU2) * Standard_Real(NbSamplesV2); - diag2/=NbSamplesUV2; - - //-- The surface with the greatest bounding box is "discretized" - - //Standard_Integer NbInterTentees=0; - - if(diag1SetValue(i+1,b);//Box b is added in the array HBnd - } - } - - //Inititalization of the boundary, sorting of boxes - BndBSB.Initialize(HBnd);//contains boxes of 2 - - Standard_Integer FinTT1Init=FinTT1; - for(Standard_Integer i_S1=0; i_S1FlecheCritique1) - Triangle1.MiddleRefinement(i_S1,MaSurface1,TPoints1, - TTriangles1, TEdges1); - - for (TColStd_ListIteratorOfListOfInteger Iter(ListeOf2); - Iter.More(); - Iter.Next()) { - Standard_Integer i_S2=Iter.Value()-1; - //if the box of s1 contacts with the boxes of s2 - //the arrow of the triangle is checked - IntPolyh_Triangle & Triangle2 = TTriangles2[i_S2]; - if(Triangle2.IndiceIntersectionPossible()!=0) - if(Triangle2.GetFleche()>FlecheCritique2) - Triangle2.MiddleRefinement( i_S2, MaSurface2, TPoints2, - TTriangles2, TEdges2); - } - } - } - } + //-- Check arrows at output + Standard_Real FlecheCritique2; + if (FlecheMin2 > FlecheMax2) { + return; + } + else { + //fleche min + (flechemax-flechemin) * 80/100 + FlecheCritique2 = FlecheMin2*0.2 + FlecheMax2*0.8; + } + + // The greatest of two bounding boxes created in FillArrayOfPoints is found. + // Then this value is weighted depending on the discretization + // (NbSamplesU and NbSamplesV) + Standard_Real diag1, diag2; + Standard_Real x0, y0, z0, x1, y1, z1; + + MyBox1.Get(x0, y0, z0, x1, y1, z1); + x0 -= x1; y0 -= y1; z0 -= z1; + diag1 = x0*x0 + y0*y0 + z0*z0; + const Standard_Real NbSamplesUV1 = Standard_Real(NbSamplesU1) * Standard_Real(NbSamplesV1); + diag1 /= NbSamplesUV1; + + MyBox2.Get(x0, y0, z0, x1, y1, z1); + x0 -= x1; y0 -= y1; z0 -= z1; + diag2 = x0*x0 + y0*y0 + z0*z0; + const Standard_Real NbSamplesUV2 = Standard_Real(NbSamplesU2) * Standard_Real(NbSamplesV2); + diag2 /= NbSamplesUV2; + + // The surface with the greatest bounding box is "discretized" + if (diag1 < diag2) { + // second is discretized + if (FlecheCritique2 < diag1) { + // The corresponding sizes are not too disproportional + TrianglesDeflectionsRefinement(MaSurface1, TTriangles1, TEdges1, TPoints1, FlecheCritique1, + MaSurface2, TTriangles2, TEdges2, TPoints2, FlecheCritique2); } - - //-------------------------------------------------------------------- - //FlecheCritique2 > diag1 else { - //2 is discretized - - Handle(Bnd_HArray1OfBox) HBnd = new Bnd_HArray1OfBox(1,FinTT2); - - for(Standard_Integer i=0; iSetValue(i+1,b);//Box b is added in array HBnd - } - } - - //Inititalization of the ouput bounding box - BndBSB.Initialize(HBnd);//contains boxes of 2 - - - //The bounding box Be1 of surface1 is compared BSB of surface2 - const TColStd_ListOfInteger& ListeOf2 = BndBSB.Compare(MyBox1); - - if((ListeOf2.IsEmpty())==0) { - //if the bounding box Be1 of s1 contacts with - //the boxes of s2 the deflection of triangle of s2 is checked - - // Be1 is very small in relation to Be2 - //The criterion of refining for surface2 depends on the size of Be1 - //As it is known that this criterion should be minimized, - //the smallest side of the bounding box is taken - MyBox1.Get(x0,y0,z0,x1,y1,z1); - Standard_Real dx=Abs(x1-x0); - Standard_Real dy=Abs(y1-y0); - Standard_Real diag=Abs(z1-z0); - Standard_Real dd=-1.0; - if (dx>dy) - dd=dy; - else - dd=dx; - if (diag>dd) diag=dd; - - //if Be1 contacts with the boxes of s2, the deflection - //of the triangles of s2 is checked (greater) - //in relation to the size of Be1 (smaller) - for (TColStd_ListIteratorOfListOfInteger Iter(ListeOf2); - Iter.More(); - Iter.Next()) { - Standard_Integer i_S2=Iter.Value()-1; - - IntPolyh_Triangle & Triangle2=TTriangles2[i_S2]; - if(Triangle2.IndiceIntersectionPossible()) { - - //calculation of the criterion of refining - //The deflection of the greater is compared to the size of the smaller - Standard_Real CritereAffinage=0.0; - Standard_Real DiagPonderation=0.5; - CritereAffinage = diag*DiagPonderation; - if(Triangle2.GetFleche()>CritereAffinage) - Triangle2.MultipleMiddleRefinement2(CritereAffinage, MyBox1, i_S2, - MaSurface2, TPoints2, - TTriangles2,TEdges2); - - else Triangle2.MiddleRefinement(i_S2,MaSurface2,TPoints2, - TTriangles2, TEdges2); - } - } - } + // second surface is much larger then the first + LargeTrianglesDeflectionsRefinement(MaSurface2, TTriangles2, TEdges2, TPoints2, MyBox1); } } - - - else { //-- The greater is discretised - - if(FlecheCritique1SetValue(i+1,b);//Boite b is added in the array HBnd - } - } - BndBSB.Initialize(HBnd); - - Standard_Integer FinTT2init=FinTT2; - for(Standard_Integer i_S2=0; i_S2FlecheCritique2) - Triangle2.MiddleRefinement(i_S2,MaSurface2,TPoints2, - TTriangles2, TEdges2); - - for (TColStd_ListIteratorOfListOfInteger Iter(ListeOf1); - Iter.More(); - Iter.Next()) { - Standard_Integer i_S1=Iter.Value()-1; - IntPolyh_Triangle & Triangle1=TTriangles1[i_S1]; - if (Triangle1.IndiceIntersectionPossible()) - if(Triangle1.GetFleche()>FlecheCritique1) - Triangle1.MiddleRefinement(i_S1,MaSurface1,TPoints1, - TTriangles1, TEdges1); - } - } - } - } + else { + // first is discretized + if (FlecheCritique1 < diag2) { + // The corresponding sizes are not too disproportional + TrianglesDeflectionsRefinement(MaSurface2, TTriangles2, TEdges2, TPoints2, FlecheCritique2, + MaSurface1, TTriangles1, TEdges1, TPoints1, FlecheCritique1); } - //----------------------------------------------------------------------------- - else {// FlecheCritique1>diag2 - // 1 is discretized - - Handle(Bnd_HArray1OfBox) HBnd = new Bnd_HArray1OfBox(1,FinTT1); - - for(Standard_Integer i=0; iSetValue(i+1,b);//Box b is added in the array HBnd - } - } - - //Inititalisation of the boundary output box - BndBSB.Initialize(HBnd);//contains boxes of 1 - - //Bounding box Be2 of surface2 is compared to BSB of surface1 - const TColStd_ListOfInteger& ListeOf1 = BndBSB.Compare(MyBox2); - - if((ListeOf1.IsEmpty())==0) { - //if the bounding box Be2 of s2 contacts - //with boxes of s1 the deflection of the triangle of s1 is checked - - // Be2 is very small compared to Be1 - //The criterion of refining for surface1 depends on the size of Be2 - //As this criterion should be minimized, - //the smallest side of the bounding box is taken - MyBox2.Get(x0,y0,z0,x1,y1,z1); - Standard_Real dx=Abs(x1-x0); - Standard_Real dy=Abs(y1-y0); - Standard_Real diag=Abs(z1-z0); - Standard_Real dd=-1.0; - if (dx>dy) - dd=dy; - else - dd=dx; - if (diag>dd) diag=dd; - - //if Be2 contacts with boxes of s1, the deflection of - //triangles of s1 (greater) is checked - //comparatively to the size of Be2 (smaller). - for (TColStd_ListIteratorOfListOfInteger Iter(ListeOf1); - Iter.More(); - Iter.Next()) { - Standard_Integer i_S1=Iter.Value()-1; - - IntPolyh_Triangle & Triangle1=TTriangles1[i_S1]; - if(Triangle1.IndiceIntersectionPossible()) { - - //calculation of the criterion of refining - //The deflection of the greater is compared - //with the size of the smaller. - Standard_Real CritereAffinage=0.0; - Standard_Real DiagPonderation=0.5; - CritereAffinage = diag*DiagPonderation;; - if(Triangle1.GetFleche()>CritereAffinage) - Triangle1.MultipleMiddleRefinement2(CritereAffinage,MyBox2, i_S1, - MaSurface1, TPoints1, - TTriangles1, TEdges1); - - else Triangle1.MiddleRefinement(i_S1,MaSurface1,TPoints1, - TTriangles1, TEdges1); - - } - } - } + else { + // first surface is much larger then the second + LargeTrianglesDeflectionsRefinement(MaSurface1, TTriangles1, TEdges1, TPoints1, MyBox2); } } } @@ -1425,7 +1357,7 @@ void TestNbPoints(const Standard_Integer , IntPolyh_StartPoint &SP1, IntPolyh_StartPoint &SP2) { - // already checked in TriangleEdgeContact2 + // already checked in TriangleEdgeContact // if( (NbPoints==2)&&(Pt1.CheckSameSP(Pt2)) ) NbPoints=1; if(NbPoints>2) { @@ -1475,113 +1407,11 @@ void TestNbPoints(const Standard_Integer , } //======================================================================= //function : StartingPointsResearch -//purpose : -//======================================================================= -Standard_Integer IntPolyh_MaillageAffinage::StartingPointsResearch - (const Standard_Integer T1, - const Standard_Integer T2, - IntPolyh_StartPoint &SP1, - IntPolyh_StartPoint &SP2) const -{ - const IntPolyh_Point &P1=TPoints1[TTriangles1[T1].FirstPoint()]; - const IntPolyh_Point &P2=TPoints1[TTriangles1[T1].SecondPoint()]; - const IntPolyh_Point &P3=TPoints1[TTriangles1[T1].ThirdPoint()]; - const IntPolyh_Point &Q1=TPoints2[TTriangles2[T2].FirstPoint()]; - const IntPolyh_Point &Q2=TPoints2[TTriangles2[T2].SecondPoint()]; - const IntPolyh_Point &Q3=TPoints2[TTriangles2[T2].ThirdPoint()]; - - - /* The first triangle is (p1,p2,p3). The other is (q1,q2,q3). - The sides are (e1,e2,e3) and (f1,f2,f3). - The normals are n1 and m1*/ - - const IntPolyh_Point e1=P2-P1; - const IntPolyh_Point e2=P3-P2; - const IntPolyh_Point e3=P1-P3; - - const IntPolyh_Point f1=Q2-Q1; - const IntPolyh_Point f2=Q3-Q2; - const IntPolyh_Point f3=Q1-Q3; - - - IntPolyh_Point nn1,mm1; - nn1.Cross(e1, e2); //normal of the first triangle - mm1.Cross(f1, f2); //normal of the second triangle - - Standard_Real nn1modulus, mm1modulus; - nn1modulus=sqrt(nn1.SquareModulus()); - mm1modulus=sqrt(mm1.SquareModulus()); - - //------------------------------------------------------- - ///calculation of intersection points between two triangles - //------------------------------------------------------- - Standard_Integer NbPoints=0; - Standard_Integer NbPointsTotal=0; - IntPolyh_StartPoint Pt1,Pt2; - - - ///check T1 normal - if(Abs(nn1modulus)1)&&( Abs(SP1.U1()-SP2.U1())1) { - - } - } - SPNext.SetCoupleValue(T1,T2); - return (NbPointsTotal); -} -//======================================================================= -//function : NextStartingPointsResearch2 //purpose : from two triangles and an intersection point I // seach the other point (if it exist). // This function is used by StartPointChain //======================================================================= -Standard_Integer IntPolyh_MaillageAffinage::NextStartingPointsResearch2 +Standard_Integer IntPolyh_MaillageAffinage::NextStartingPointsResearch (const Standard_Integer T1, const Standard_Integer T2, const IntPolyh_StartPoint &SPInit, @@ -1887,19 +1589,19 @@ Standard_Integer IntPolyh_MaillageAffinage::NextStartingPointsResearch2 ///T2 edges with T1 if( (NbPointsTotal<3)&&(EdgeInit2!=Tri2.FirstEdge()) ) { IntPolyh_StartPoint Pt1,Pt2; - NbPoints=TriangleEdgeContact2(1,1,Tri1,Tri2,P1,P2,P3,e1,e2,e3,Q1,Q2,f1,n1,Pt1,Pt2); + NbPoints=TriangleEdgeContact(1,1,Tri1,Tri2,P1,P2,P3,e1,e2,e3,Q1,Q2,f1,n1,Pt1,Pt2); TestNbPoints(1,NbPoints,NbPointsTotal,Pt1,Pt2,SP1,SP2); } if( (NbPointsTotal<3)&&(EdgeInit2!=Tri2.SecondEdge()) ) { IntPolyh_StartPoint Pt1,Pt2; - NbPoints=TriangleEdgeContact2(1,2,Tri1,Tri2,P1,P2,P3,e1,e2,e3,Q2,Q3,f2,n1,Pt1,Pt2); + NbPoints=TriangleEdgeContact(1,2,Tri1,Tri2,P1,P2,P3,e1,e2,e3,Q2,Q3,f2,n1,Pt1,Pt2); TestNbPoints(1,NbPoints,NbPointsTotal,Pt1,Pt2,SP1,SP2); } if( (NbPointsTotal<3)&&(EdgeInit2!=Tri2.ThirdEdge()) ) { IntPolyh_StartPoint Pt1,Pt2; - NbPoints=TriangleEdgeContact2(1,3,Tri1,Tri2,P1,P2,P3,e1,e2,e3,Q3,Q1,f3,n1,Pt1,Pt2); + NbPoints=TriangleEdgeContact(1,3,Tri1,Tri2,P1,P2,P3,e1,e2,e3,Q3,Q1,f3,n1,Pt1,Pt2); TestNbPoints(1,NbPoints,NbPointsTotal,Pt1,Pt2,SP1,SP2); } } @@ -1912,19 +1614,19 @@ Standard_Integer IntPolyh_MaillageAffinage::NextStartingPointsResearch2 ///T1 edges with T2 if( (NbPointsTotal<3)&&(EdgeInit1!=Tri1.FirstEdge()) ) { IntPolyh_StartPoint Pt1,Pt2; - NbPoints=TriangleEdgeContact2(2,1,Tri1,Tri2,Q1,Q2,Q3,f1,f2,f3,P1,P2,e1,m1,Pt1,Pt2); + NbPoints=TriangleEdgeContact(2,1,Tri1,Tri2,Q1,Q2,Q3,f1,f2,f3,P1,P2,e1,m1,Pt1,Pt2); TestNbPoints(2,NbPoints,NbPointsTotal,Pt1,Pt2,SP1,SP2); } if( (NbPointsTotal<3)&&(EdgeInit1!=Tri1.SecondEdge()) ) { IntPolyh_StartPoint Pt1,Pt2; - NbPoints=TriangleEdgeContact2(2,2,Tri1,Tri2,Q1,Q2,Q3,f1,f2,f3,P2,P3,e2,m1,Pt1,Pt2); + NbPoints=TriangleEdgeContact(2,2,Tri1,Tri2,Q1,Q2,Q3,f1,f2,f3,P2,P3,e2,m1,Pt1,Pt2); TestNbPoints(2,NbPoints,NbPointsTotal,Pt1,Pt2,SP1,SP2); } if( (NbPointsTotal<3)&&(EdgeInit1!=Tri1.ThirdEdge()) ) { IntPolyh_StartPoint Pt1,Pt2; - NbPoints=TriangleEdgeContact2(2,3,Tri1,Tri2,Q1,Q2,Q3,f1,f2,f3,P3,P1,e3,m1,Pt1,Pt2); + NbPoints=TriangleEdgeContact(2,3,Tri1,Tri2,Q1,Q2,Q3,f1,f2,f3,P3,P1,e3,m1,Pt1,Pt2); TestNbPoints(2,NbPoints,NbPointsTotal,Pt1,Pt2,SP1,SP2); } } @@ -1958,216 +1660,19 @@ Standard_Integer IntPolyh_MaillageAffinage::NextStartingPointsResearch2 //======================================================================= void CalculPtsInterTriEdgeCoplanaires(const Standard_Integer TriSurfID, const IntPolyh_Point &NormaleTri, + const IntPolyh_Triangle &Tri1, + const IntPolyh_Triangle &Tri2, const IntPolyh_Point &PE1, const IntPolyh_Point &PE2, const IntPolyh_Point &Edge, + const Standard_Integer EdgeIndex, const IntPolyh_Point &PT1, const IntPolyh_Point &PT2, const IntPolyh_Point &Cote, const Standard_Integer CoteIndex, IntPolyh_StartPoint &SP1, IntPolyh_StartPoint &SP2, - Standard_Integer &NbPoints) -{ - IntPolyh_Point TestParalleles; - TestParalleles.Cross(Edge,Cote); - if(sqrt(TestParalleles.SquareModulus())=p0p)&&(p2p<=p0p) )||( (p1p<=p0p)&&(p2p>=p0p) ) ) { - Standard_Real lambda=(p1p-p0p)/(p1p-p2p); - if (lambda<-MyConfusionPrecision) { - - } - IntPolyh_Point PIE=PE1+Edge*lambda; - Standard_Real alpha=RealLast(); - if(Cote.X()!=0) alpha=(PIE.X()-PT1.X())/Cote.X(); - else if (Cote.Y()!=0) alpha=(PIE.Y()-PT1.Y())/Cote.Y(); - else if (Cote.Z()!=0) alpha=(PIE.Z()-PT1.Z())/Cote.Z(); - else { - - } - if (alpha<-MyConfusionPrecision) { - - } - else { - if (NbPoints==0) { - SP1.SetXYZ(PIE.X(),PIE.Y(),PIE.Z()); - if (TriSurfID==1) { - SP1.SetUV1(PT1.U()+Cote.U()*alpha,PT1.V()+Cote.V()*alpha); - SP1.SetUV2(PIE.U(),PIE.V()); - SP1.SetEdge1(CoteIndex); - NbPoints++; - } - else if (TriSurfID==2) { - SP1.SetUV1(PIE.U(),PIE.V()); - SP1.SetUV2(PT1.U()+Cote.U()*alpha,PT1.V()+Cote.V()*alpha); - SP1.SetEdge2(CoteIndex); - NbPoints++; - } - else { - - } - } - - else if (NbPoints==1) { - SP2.SetXYZ(PIE.X(),PIE.Y(),PIE.Z()); - if (TriSurfID==1) { - SP2.SetUV1(PT1.U()+Cote.U()*alpha,PT1.V()+Cote.V()*alpha); - SP2.SetUV2(PIE.U(),PIE.V()); - SP2.SetEdge1(CoteIndex); - NbPoints++; - } - else if (TriSurfID==2) { - SP2.SetUV1(PIE.U(),PIE.V()); - SP2.SetUV2(PT1.U()+Cote.U()*alpha,PT1.V()+Cote.V()*alpha); - SP2.SetEdge2(CoteIndex); - NbPoints++; - } - else { - - } - } - - else if( (NbPoints>2)||(NbPoints<0) ) { - - } - } - } - } - else { //Cote et Edge paralleles, avec les rejections precedentes ils sont sur la meme droite - //On projette les points sur cette droite - Standard_Real pe1p= Cote.Dot(PE1); - Standard_Real pe2p= Cote.Dot(PE2); - Standard_Real pt1p= Cote.Dot(PT1); - Standard_Real pt2p= Cote.Dot(PT2); - - IntPolyh_Point PEP1,PTP1,PEP2,PTP2; - - //PEP1 et PEP2 sont les points de contact entre le triangle et l'edge dans le repere UV de l'edge - //PTP1 et PTP2 sont les correspondants respectifs a PEP1 et PEP2 dans le repere UV du triangle - - - if (pe1p>pe2p) { - if ( (pt1p free intersection (point I)--> start point is found*/ - Standard_Integer NbPoints=0; - - if(NormaleT.SquareModulus()==0) { - - } - else if( (Cote12.SquareModulus()==0) - ||(Cote23.SquareModulus()==0) - ||(Cote31.SquareModulus()==0) ) { - - } - else if(Edge.SquareModulus()==0) { - - } - else { - Standard_Real pe1 = NormaleT.Dot(PE1); - Standard_Real pe2 = NormaleT.Dot(PE2); - Standard_Real pt1 = NormaleT.Dot(PT1); - - // PE1I = lambda.Edge - - if( (Abs(pe1-pe2)ppe1)&&(pp2<=ppe1)&&(pp3<=ppe1) ) || ( (pp1=ppe1)&&(pp3>=ppe1) ) ){ - //there are two sides (commun top PT1) that can cut the edge - - //first side - CalculPtsInterTriEdgeCoplanaires(TriSurfID,NormaleT, - PE1,PE2,Edge,PT1,PT2, - Cote12,1,SP1,SP2,NbPoints); - - if ( (NbPoints>1)&&(Abs(SP2.U1()-SP1.U1())1)&&(Abs(SP1.U1()-SP2.U1())=2) return(NbPoints); - - else if ( ( ( (pp2>ppe1)&&(pp1<=ppe1)&&(pp3<=ppe1) ) || ( (pp2=ppe1)&&(pp3>=ppe1) ) ) - && (NbPoints<2) ) { - //there are two sides (common top PT2) that can cut the edge - - //first side - CalculPtsInterTriEdgeCoplanaires(TriSurfID,NormaleT, - PE1,PE2,Edge,PT1,PT2, - Cote12,1,SP1,SP2,NbPoints); - - if ( (NbPoints>1)&&(Abs(SP2.U1()-SP1.U1())1)&&(Abs(SP2.U1()-SP1.U1())=2) return(NbPoints); - //= remove - else if ( (( (pp3>ppe1)&&(pp1<=ppe1)&&(pp2<=ppe1) ) || ( (pp3=ppe1)&&(pp2>=ppe1) )) - && (NbPoints<2) ) { - //there are two sides (common top PT3) that can cut the edge - - //first side - CalculPtsInterTriEdgeCoplanaires(TriSurfID,NormaleT, - PE1,PE2,Edge,PT3,PT1,Cote31, - 3,SP1,SP2,NbPoints); - - if ( (NbPoints>1)&&(Abs(SP2.U1()-SP1.U1())1)&&(Abs(SP2.U1()-SP1.U1())=2) return(NbPoints); - } - - - //------------------------------------------------------ - // edge and triangle NON COPLANAR (a contact point) - //------------------------------------------------------ - else if( ( (pe1>=pt1)&&(pe2<=pt1) ) || ( (pe1<=pt1)&&(pe2>=pt1) ) ) { - lambda=(pe1-pt1)/(pe1-pe2); - IntPolyh_Point PI; - if (lambda<-MyConfusionPrecision) { - - } - else if (Abs(lambda)MyConfusionPrecision) { - Standard_Real D=(Cote12.Y()-Cote12.X()*Cote23.Y()/Cote23.X()); - if(D!=0) alpha = (PI.Y()-PT1.Y()-(PI.X()-PT1.X())*Cote23.Y()/Cote23.X())/D; - else { - - } - if ((alpha<-MyConfusionPrecision)||(alpha>(1.0+MyConfusionPrecision))) return(0); - else beta = (PI.X()-PT1.X()-alpha*Cote12.X())/Cote23.X(); - } - - else if (Abs(Cote12.X())>MyConfusionPrecision) { //On a Cote23.X()==0 - alpha = (PI.X()-PT1.X())/Cote12.X(); - - if ((alpha<-MyConfusionPrecision)||(alpha>(1.0+MyConfusionPrecision))) return(0); - - else if (Abs(Cote23.Y())>MyConfusionPrecision) beta = (PI.Y()-PT1.Y()-alpha*Cote12.Y())/Cote23.Y(); - else if (Abs(Cote23.Z())>MyConfusionPrecision) beta = (PI.Z()-PT1.Z()-alpha*Cote12.Z())/Cote23.Z(); - else { - - } - } - - else if (Abs(Cote23.Y())>MyConfusionPrecision) { - //On a Cote23.X()==0 et Cote12.X()==0 ==> equation can't be used - Standard_Real D=(Cote12.Z()-Cote12.Y()*Cote23.Z()/Cote23.Y()); - - if(D!=0) alpha = (PI.Z()-PT1.Z()-(PI.Y()-PT1.Y())*Cote23.Z()/Cote23.Y())/D; - else{ - - } - - if ( (alpha<-MyConfusionPrecision)||(alpha>(1.0+MyConfusionPrecision)) ) return(0); - else beta = (PI.Y()-PT1.Y()-alpha*Cote12.Y())/Cote23.Y(); - } - - else if (Abs(Cote12.Y())>MyConfusionPrecision) { - //On a Cote23.X()==0, Cote12.X()==0 et Cote23.Y()==0 - alpha = (PI.Y()-PT1.Y())/Cote12.Y(); - - if ((Abs(alpha)MyConfusionPrecision) beta = (PI.Z()-PT1.Z()-alpha*Cote12.Z())/Cote23.Z(); - - else { - - } - } - - else { //two equations of three can't be used - - alpha=RealLast(); - beta=RealLast(); - } - - if( (beta<-MyConfusionPrecision)||(beta>(alpha+MyConfusionPrecision)) ) return(0); - else { - SP1.SetXYZ(PI.X(),PI.Y(),PI.Z()); - - if (TriSurfID==1) { - SP1.SetUV2(PI.U(),PI.V()); - SP1.SetUV1(PT1.U()+Cote12.U()*alpha+Cote23.U()*beta, PT1.V()+Cote12.V()*alpha+Cote23.V()*beta); - NbPoints++; - if (beta beta==0 - SP1.SetXYZ(PT1.X(),PT1.Y(),PT1.Z()); - SP1.SetUV1(PT1.U(),PT1.V()); - SP1.SetEdge1(0); - } - if ( (beta beta==0 - SP1.SetXYZ(PT1.X(),PT1.Y(),PT1.Z()); - SP1.SetUV2(PT1.U(),PT1.V()); - SP1.SetEdge2(0); - } - if ( (beta1)&&(Abs(SP2.U1()-SP1.U1())1)&&(Abs(SP1.U1()-SP2.U1())1)&&(Abs(SP2.U1()-SP1.U1())1)&&(Abs(SP2.U1()-SP1.U1())1)&&(Abs(SP2.U1()-SP1.U1())1)&&(Abs(SP2.U1()-SP1.U1())= 0.)) { - IntPolyh_StartPoint SP1, SP2; - //If a triangle is dead or not in BSB, comparison is not possible - // - Standard_Integer iDeg1, iDeg2, iDeg3, iDeg; - // - const IntPolyh_Point& P1=TPoints1[Triangle1.FirstPoint()]; - const IntPolyh_Point& P2=TPoints1[Triangle1.SecondPoint()]; - const IntPolyh_Point& P3=TPoints1[Triangle1.ThirdPoint()]; - iDeg1=(P1.Degenerated()) ? 1 : 0; - iDeg2=(P2.Degenerated()) ? 1 : 0; - iDeg3=(P3.Degenerated()) ? 1 : 0; - iDeg=iDeg1+iDeg2+iDeg3; - if (iDeg>1) { - continue; - } - // - const IntPolyh_Point& Q1=TPoints2[Triangle2.FirstPoint()]; - const IntPolyh_Point& Q2=TPoints2[Triangle2.SecondPoint()]; - const IntPolyh_Point& Q3=TPoints2[Triangle2.ThirdPoint()]; - iDeg1=(Q1.Degenerated()) ? 1 : 0; - iDeg2=(Q2.Degenerated()) ? 1 : 0; - iDeg3=(Q3.Degenerated()) ? 1 : 0; - iDeg=iDeg1+iDeg2+iDeg3; - if (iDeg>1) { - continue; - } - // - if (TriContact(P1, P2, P3, Q1, Q2, Q3, CoupleAngle)) { - Triangle1.SetIndiceIntersection(1);//The triangle is cut by another - Triangle2.SetIndiceIntersection(1); - - Standard_Integer NbPoints; - NbPoints=StartingPointsResearch(i_S1,i_S2,SP1, SP2); - - if (NbPoints==0) { - - } - - if ( (NbPoints>0)&&(NbPoints<3) ) { - SP1.SetCoupleValue(i_S1,i_S2); - TStartPoints[CpteurTabSP]=SP1; - CpteurTabSP++; - - - } - - if(NbPoints==2) { - SP2.SetCoupleValue(i_S1,i_S2); - TStartPoints[CpteurTabSP]=SP2; - CpteurTabSP++; - - - } - - if(NbPoints>2) { - - } - CpteurTab++; - } - } - } - } - return(CpteurTabSP); -} -//======================================================================= //function : TriangleCompare //purpose : Analyze each couple of triangles from the two -- // array of triangles, to see if they are in @@ -3215,167 +2347,121 @@ Standard_Integer IntPolyh_MaillageAffinage::TriangleComparePSP () //======================================================================= Standard_Integer IntPolyh_MaillageAffinage::TriangleCompare () { - Standard_Integer CpteurTab=0; - - const Standard_Integer FinTT1 = TTriangles1.NbItems(); - const Standard_Integer FinTT2 = TTriangles2.NbItems(); - - Standard_Integer TTClimit = 200; - Standard_Integer NbTTC = FinTT1 * FinTT2 / 10; - if (NbTTC < TTClimit) - NbTTC = TTClimit; - TTrianglesContacts.Init(NbTTC); - // eap - //TTrianglesContacts.Init(FinTT1 * FinTT2 / 10); - - Standard_Real CoupleAngle=-2.0; - for(Standard_Integer i_S1=0; i_S1= 0.)) { - //If a triangle is dead or not in BSB, comparison is not possible - Standard_Integer iDeg1, iDeg2, iDeg3, iDeg; + const IntPolyh_Point& Q1 = TPoints2[Triangle2.FirstPoint()]; + const IntPolyh_Point& Q2 = TPoints2[Triangle2.SecondPoint()]; + const IntPolyh_Point& Q3 = TPoints2[Triangle2.ThirdPoint()]; + // + if (TriContact(P1, P2, P3, Q1, Q2, Q3, CoupleAngle)) { + IntPolyh_Couple aCouple(i_S1, i_S2, CoupleAngle); + TTrianglesContacts.Append(aCouple); // - const IntPolyh_Point& P1=TPoints1[Triangle1.FirstPoint()]; - const IntPolyh_Point& P2=TPoints1[Triangle1.SecondPoint()]; - const IntPolyh_Point& P3=TPoints1[Triangle1.ThirdPoint()]; - iDeg1=(P1.Degenerated()) ? 1 : 0; - iDeg2=(P2.Degenerated()) ? 1 : 0; - iDeg3=(P3.Degenerated()) ? 1 : 0; - iDeg=iDeg1+iDeg2+iDeg3; - if (iDeg>1) { - continue; - } - // - const IntPolyh_Point& Q1=TPoints2[Triangle2.FirstPoint()]; - const IntPolyh_Point& Q2=TPoints2[Triangle2.SecondPoint()]; - const IntPolyh_Point& Q3=TPoints2[Triangle2.ThirdPoint()]; - iDeg1=(Q1.Degenerated()) ? 1 : 0; - iDeg2=(Q2.Degenerated()) ? 1 : 0; - iDeg3=(Q3.Degenerated()) ? 1 : 0; - iDeg=iDeg1+iDeg2+iDeg3; - if (iDeg>1) { - continue; - } - // - if (TriContact(P1, P2, P3, Q1, Q2, Q3, CoupleAngle)) { - if (CpteurTab >= NbTTC) - { - TTrianglesContacts.SetNbItems(CpteurTab); - return(CpteurTab); - } - TTrianglesContacts[CpteurTab].SetCoupleValue(i_S1, i_S2); - TTrianglesContacts[CpteurTab].SetAngleValue(CoupleAngle); - //test TTrianglesContacts[CpteurTab].Dump(CpteurTab); - - Triangle1.SetIndiceIntersection(1);//The triangle is cut by another - Triangle2.SetIndiceIntersection(1); - CpteurTab++; - } + Triangle1.SetIntersection(Standard_True); + Triangle2.SetIntersection(Standard_True); } } } - TTrianglesContacts.SetNbItems(CpteurTab); - - return(CpteurTab); + return TTrianglesContacts.Extent(); } -//======================================================================= -//function : StartPointsCalcul -//purpose : From the array of couples compute all the start -// points and display them on the screen -//======================================================================= -void IntPolyh_MaillageAffinage::StartPointsCalcul() const -{ - const Standard_Integer FinTTC = TTrianglesContacts.NbItems(); -// printf("StartPointsCalcul() from IntPolyh_MaillageAffinage.cxx : StartPoints:\n"); - for(Standard_Integer ii=0; ii1) CheckNextStartPoint(MySectionLine,TTangentZones,SPNext,Prepend); @@ -3677,7 +2761,7 @@ Standard_Integer IntPolyh_MaillageAffinage::GetNextChainStartPoint NextTriangle2=TEdges2[SP.E2()].SecondTriangle(); Standard_Real Angle= -2.0; if (CheckCoupleAndGetAngle(SP.T1(),NextTriangle2,Angle,TTrianglesContacts)) { - NbPoints=NextStartingPointsResearch2(SP.T1(),NextTriangle2,SP,SPNext); + NbPoints=NextStartingPointsResearch(SP.T1(),NextTriangle2,SP,SPNext); if( NbPoints!=1 ) { if (NbPoints>1) CheckNextStartPoint(MySectionLine,TTangentZones,SPNext,Prepend); @@ -3699,8 +2783,6 @@ Standard_Integer IntPolyh_MaillageAffinage::GetNextChainStartPoint else if( (SP.E1()>=0)&&(SP.E2()>=0) ) { ///the point is located on two edges Standard_Integer NextTriangle1; - Standard_Integer CpleT11=-1; - Standard_Integer CpleT22=-1; if (TEdges1[SP.E1()].FirstTriangle()!=SP.T1()) NextTriangle1=TEdges1[SP.E1()].FirstTriangle(); else NextTriangle1=TEdges1[SP.E1()].SecondTriangle(); @@ -3709,10 +2791,12 @@ Standard_Integer IntPolyh_MaillageAffinage::GetNextChainStartPoint else NextTriangle2=TEdges2[SP.E2()].SecondTriangle(); Standard_Real Angle= -2.0; + + IntPolyh_ListIteratorOfListOfCouples aItCT11, aItCT22; if (CheckCoupleAndGetAngle2(NextTriangle1,NextTriangle2, - SP.T1(),SP.T2(),CpleT11,CpleT22, + SP.T1(),SP.T2(), aItCT11, aItCT22, Angle,TTrianglesContacts)) { - NbPoints=NextStartingPointsResearch2(NextTriangle1,NextTriangle2,SP,SPNext); + NbPoints=NextStartingPointsResearch(NextTriangle1,NextTriangle2,SP,SPNext); if( NbPoints!=1 ) { if (NbPoints>1) { ///The new point is checked @@ -3725,16 +2809,9 @@ Standard_Integer IntPolyh_MaillageAffinage::GetNextChainStartPoint NbPoints=0; } else {//NbPoints==1 - SPNext.SetAngle(Angle); - //The couples (Ti,Tj) (Ti',Tj') are marked - if (CpleT11>=0) TTrianglesContacts[CpleT11].SetAnalyseFlag(1); - else { - - } - if (CpleT22>=0) TTrianglesContacts[CpleT22].SetAnalyseFlag(1); - else { - - } + SPNext.SetAngle(Angle); + if (aItCT11.More()) aItCT11.ChangeValue().SetAnalyzed(Standard_True); + if (aItCT22.More()) aItCT22.ChangeValue().SetAnalyzed(Standard_True); } } else NbPoints=0; @@ -3789,26 +2866,11 @@ Bnd_Box IntPolyh_MaillageAffinage::GetBox(const Standard_Integer SurfID) const return(MyBox1); return(MyBox2); } - -//======================================================================= -//function : GetBoxDraw -//purpose : -//======================================================================= -void IntPolyh_MaillageAffinage::GetBoxDraw(const Standard_Integer SurfID)const -{ -Standard_Real x0,y0,z0,x1,y1,z1; - if (SurfID==1) { - MyBox1.Get(x0,y0,z0,x1,y1,z1); - } - else { - MyBox2.Get(x0,y0,z0,x1,y1,z1); - } -} //======================================================================= //function : GetArrayOfCouples //purpose : //======================================================================= -IntPolyh_ArrayOfCouples &IntPolyh_MaillageAffinage::GetArrayOfCouples() +IntPolyh_ListOfCouples &IntPolyh_MaillageAffinage::GetCouples() { return TTrianglesContacts; } diff --git a/src/IntPolyh/IntPolyh_MaillageAffinage.hxx b/src/IntPolyh/IntPolyh_MaillageAffinage.hxx index 6ba243335a..693b581a5f 100644 --- a/src/IntPolyh/IntPolyh_MaillageAffinage.hxx +++ b/src/IntPolyh/IntPolyh_MaillageAffinage.hxx @@ -27,8 +27,7 @@ #include #include #include -#include -#include +#include #include #include #include @@ -92,10 +91,6 @@ public: //! CommonBox function. Standard_EXPORT void FillArrayOfTriangles (const Standard_Integer SurfID); - //! fill the edge fields in Triangle object for the - //! two array of triangles. - Standard_EXPORT void LinkEdges2Triangles(); - //! Refine systematicaly all marked triangles of both surfaces Standard_EXPORT void CommonPartRefinement(); @@ -118,23 +113,17 @@ public: //! if no. Standard_EXPORT Standard_Integer TriContact (const IntPolyh_Point& P1, const IntPolyh_Point& P2, const IntPolyh_Point& P3, const IntPolyh_Point& Q1, const IntPolyh_Point& Q2, const IntPolyh_Point& Q3, Standard_Real& Angle) const; - Standard_EXPORT Standard_Integer TriangleEdgeContact (const Standard_Integer TriSurfID, const Standard_Integer EdgeIndice, const IntPolyh_Point& P1, const IntPolyh_Point& P2, const IntPolyh_Point& P3, const IntPolyh_Point& C1, const IntPolyh_Point& C2, const IntPolyh_Point& C3, const IntPolyh_Point& Pe1, const IntPolyh_Point& Pe2, const IntPolyh_Point& E, const IntPolyh_Point& N, IntPolyh_StartPoint& SP1, IntPolyh_StartPoint& SP2) const; - - Standard_EXPORT Standard_Integer TriangleEdgeContact2 (const Standard_Integer TriSurfID, const Standard_Integer EdgeIndice, const IntPolyh_Triangle& Tri1, const IntPolyh_Triangle& Tri2, const IntPolyh_Point& P1, const IntPolyh_Point& P2, const IntPolyh_Point& P3, const IntPolyh_Point& C1, const IntPolyh_Point& C2, const IntPolyh_Point& C3, const IntPolyh_Point& Pe1, const IntPolyh_Point& Pe2, const IntPolyh_Point& E, const IntPolyh_Point& N, IntPolyh_StartPoint& SP1, IntPolyh_StartPoint& SP2) const; - - Standard_EXPORT Standard_Integer StartingPointsResearch (const Standard_Integer T1, const Standard_Integer T2, IntPolyh_StartPoint& SP1, IntPolyh_StartPoint& SP2) const; + Standard_EXPORT Standard_Integer TriangleEdgeContact (const Standard_Integer TriSurfID, const Standard_Integer EdgeIndice, const IntPolyh_Triangle& Tri1, const IntPolyh_Triangle& Tri2, const IntPolyh_Point& P1, const IntPolyh_Point& P2, const IntPolyh_Point& P3, const IntPolyh_Point& C1, const IntPolyh_Point& C2, const IntPolyh_Point& C3, const IntPolyh_Point& Pe1, const IntPolyh_Point& Pe2, const IntPolyh_Point& E, const IntPolyh_Point& N, IntPolyh_StartPoint& SP1, IntPolyh_StartPoint& SP2) const; //! From two triangles compute intersection points. //! If I found more than two intersection points //! that's mean that those triangle are coplanar - Standard_EXPORT Standard_Integer StartingPointsResearch2 (const Standard_Integer T1, const Standard_Integer T2, IntPolyh_StartPoint& SP1, IntPolyh_StartPoint& SP2) const; - - Standard_EXPORT Standard_Integer NextStartingPointsResearch (const Standard_Integer T1, const Standard_Integer T2, const IntPolyh_StartPoint& SPInit, IntPolyh_StartPoint& SPNext) const; + Standard_EXPORT Standard_Integer StartingPointsResearch (const Standard_Integer T1, const Standard_Integer T2, IntPolyh_StartPoint& SP1, IntPolyh_StartPoint& SP2) const; //! from two triangles and an intersection point I //! seach the other point (if it exist). //! This function is used by StartPointChain - Standard_EXPORT Standard_Integer NextStartingPointsResearch2 (const Standard_Integer T1, const Standard_Integer T2, const IntPolyh_StartPoint& SPInit, IntPolyh_StartPoint& SPNext) const; + Standard_EXPORT Standard_Integer NextStartingPointsResearch (const Standard_Integer T1, const Standard_Integer T2, const IntPolyh_StartPoint& SPInit, IntPolyh_StartPoint& SPNext) const; //! Analyse each couple of triangles from the two -- //! array of triangles, to see if they are in @@ -142,14 +131,6 @@ public: //! couples in contact in the array of couples Standard_EXPORT Standard_Integer TriangleCompare(); - //! The same as TriangleCompare, plus compute the - //! StartPoints without chaining them. - Standard_EXPORT Standard_Integer TriangleComparePSP(); - - //! From the array of couples compute all the start - //! points and display them on the screen - Standard_EXPORT void StartPointsCalcul() const; - //! Loop on the array of couples. Compute StartPoints. //! Try to chain the StartPoints into SectionLines or //! put the point in the ArrayOfTangentZones if @@ -172,12 +153,8 @@ public: Standard_EXPORT Bnd_Box GetBox (const Standard_Integer SurfID) const; - Standard_EXPORT void GetBoxDraw (const Standard_Integer SurfID) const; - - Standard_EXPORT const IntPolyh_ArrayOfStartPoints& GetArrayOfSP() const; - - //! This method returns array of couples of contact triangles. - Standard_EXPORT IntPolyh_ArrayOfCouples& GetArrayOfCouples(); + //! This method returns list of couples of contact triangles. + Standard_EXPORT IntPolyh_ListOfCouples& GetCouples(); Standard_EXPORT void SetEnlargeZone (Standard_Boolean& EnlargeZone); @@ -190,14 +167,9 @@ public: Standard_EXPORT Standard_Real GetMaxDeflection (const Standard_Integer SurfID) const; - - protected: - - - private: @@ -216,23 +188,21 @@ private: Standard_Real FlecheMin2; Standard_Real FlecheMoy1; Standard_Real FlecheMoy2; + // For the arrays of Points, Edges and Triangles we need instant access to the items. + // Moreover, we might add new items during refinement process in case the deflection + // is too big, thus the vectors should be used. IntPolyh_ArrayOfPoints TPoints1; IntPolyh_ArrayOfPoints TPoints2; IntPolyh_ArrayOfEdges TEdges1; IntPolyh_ArrayOfEdges TEdges2; IntPolyh_ArrayOfTriangles TTriangles1; IntPolyh_ArrayOfTriangles TTriangles2; - IntPolyh_ArrayOfCouples TTrianglesContacts; - IntPolyh_ArrayOfStartPoints TStartPoints; - Standard_Boolean myEnlargeZone; + // The intersecting triangles are just filled and then + // sequentially analyzed, thus we might use the list. + IntPolyh_ListOfCouples TTrianglesContacts; + Standard_Boolean myEnlargeZone; }; - - - - - - #endif // _IntPolyh_MaillageAffinage_HeaderFile diff --git a/src/IntPolyh/IntPolyh_Point.cxx b/src/IntPolyh/IntPolyh_Point.cxx index 5788a7e403..a1ac8a9b31 100644 --- a/src/IntPolyh/IntPolyh_Point.cxx +++ b/src/IntPolyh/IntPolyh_Point.cxx @@ -19,159 +19,6 @@ #include #include -//======================================================================= -//function : IntPolyh_Point -//purpose : -//======================================================================= -IntPolyh_Point::IntPolyh_Point() -: - x(0),y(0),z(0),u(0),v(0),POC(1), - myDegenerated(Standard_False) -{ -} - -//======================================================================= -//function : IntPolyh_Point -//purpose : -//======================================================================= -IntPolyh_Point::IntPolyh_Point(const Standard_Real _x, - const Standard_Real _y, - const Standard_Real _z, - const Standard_Real _u, - const Standard_Real _v) -: - POC(1), - myDegenerated(Standard_False) -{ - x=_x; y=_y; z=_z; u=_u; v=_v; -} -//======================================================================= -//function : X -//purpose : -//======================================================================= -Standard_Real IntPolyh_Point::X() const -{ - return x; -} -//======================================================================= -//function : Y -//purpose : -//======================================================================= -Standard_Real IntPolyh_Point::Y() const -{ - return y; -} -//======================================================================= -//function : Z -//purpose : -//======================================================================= -Standard_Real IntPolyh_Point::Z() const -{ - return z; - } -//======================================================================= -//function : U -//purpose : -//======================================================================= -Standard_Real IntPolyh_Point::U() const -{ - return u; -} -//======================================================================= -//function : V -//purpose : -//======================================================================= -Standard_Real IntPolyh_Point::V() const -{ - return v; -} -//======================================================================= -//function : PartOfCommon -//purpose : -//======================================================================= -Standard_Integer IntPolyh_Point::PartOfCommon() const -{ - return POC; -} -//======================================================================= -//function : Set -//purpose : -//======================================================================= -void IntPolyh_Point::Set(const Standard_Real _x, - const Standard_Real _y, - const Standard_Real _z, - const Standard_Real _u, - const Standard_Real _v, - const Standard_Integer II) -{ - x=_x; - y=_y; - z=_z; - u=_u; - v=_v; - POC=II; -} -//======================================================================= -//function : Equal -//purpose : -//======================================================================= -void IntPolyh_Point::Equal(const IntPolyh_Point &Pt) -{ - x = Pt.x; - y = Pt.y; - z = Pt.z; - u = Pt.u; - v = Pt.v; -} -//======================================================================= -//function : SetX -//purpose : -//======================================================================= -void IntPolyh_Point::SetX(const Standard_Real _x) -{ - x=_x; -} -//======================================================================= -//function : SetY -//purpose : -//======================================================================= -void IntPolyh_Point::SetY(const Standard_Real _y) -{ - y=_y; -} -//======================================================================= -//function : SetZ -//purpose : -//======================================================================= -void IntPolyh_Point::SetZ(const Standard_Real _z) -{ - z=_z; -} -//======================================================================= -//function : SetU -//purpose : -//======================================================================= -void IntPolyh_Point::SetU(const Standard_Real _u) -{ - u=_u; -} -//======================================================================= -//function : SetV -//purpose : -//======================================================================= -void IntPolyh_Point::SetV(const Standard_Real _v) -{ - v=_v; -} -//======================================================================= -//function : SetPartOfCommon -//purpose : -//======================================================================= -void IntPolyh_Point::SetPartOfCommon(const Standard_Integer ii) -{ - POC=ii; -} - //======================================================================= //function : Middle @@ -180,14 +27,14 @@ void IntPolyh_Point::SetPartOfCommon(const Standard_Integer ii) void IntPolyh_Point::Middle(const Handle(Adaptor3d_HSurface)& MySurface, const IntPolyh_Point & Point1, const IntPolyh_Point & Point2){ - u = (Point1.U()+Point2.U())*0.5; - v = (Point1.V()+Point2.V())*0.5; + myU = (Point1.U()+Point2.U())*0.5; + myV = (Point1.V()+Point2.V())*0.5; - gp_Pnt PtXYZ = (MySurface)->Value(u, v); + gp_Pnt PtXYZ = (MySurface)->Value(myU, myV); - x=PtXYZ.X(); - y=PtXYZ.Y(); - z=PtXYZ.Z(); + myX=PtXYZ.X(); + myY=PtXYZ.Y(); + myZ=PtXYZ.Z(); } //======================================================================= //function : Add @@ -197,11 +44,11 @@ IntPolyh_Point IntPolyh_Point::Add(const IntPolyh_Point &P1)const { IntPolyh_Point res; // - res.SetX(x+P1.X()); - res.SetY(y+P1.Y()); - res.SetZ(z+P1.Z()); - res.SetU(u+P1.U()); - res.SetV(v+P1.V()); + res.SetX(myX+P1.X()); + res.SetY(myY+P1.Y()); + res.SetZ(myZ+P1.Z()); + res.SetU(myU+P1.U()); + res.SetV(myV+P1.V()); return res; } @@ -213,11 +60,11 @@ IntPolyh_Point IntPolyh_Point::Sub(const IntPolyh_Point &P1)const { IntPolyh_Point res; // - res.SetX(x-P1.X()); - res.SetY(y-P1.Y()); - res.SetZ(z-P1.Z()); - res.SetU(u-P1.U()); - res.SetV(v-P1.V()); + res.SetX(myX-P1.X()); + res.SetY(myY-P1.Y()); + res.SetZ(myZ-P1.Z()); + res.SetU(myU-P1.U()); + res.SetV(myV-P1.V()); return res; } //======================================================================= @@ -229,11 +76,11 @@ IntPolyh_Point IntPolyh_Point::Divide(const Standard_Real RR)const IntPolyh_Point res; // if (Abs(RR)>10.0e-20) { - res.SetX(x/RR); - res.SetY(y/RR); - res.SetZ(z/RR); - res.SetU(u/RR); - res.SetV(v/RR); + res.SetX(myX/RR); + res.SetY(myY/RR); + res.SetZ(myZ/RR); + res.SetU(myU/RR); + res.SetV(myV/RR); } else { printf("Division par zero RR=%f\n",RR); @@ -248,11 +95,11 @@ IntPolyh_Point IntPolyh_Point::Multiplication(const Standard_Real RR)const { IntPolyh_Point res; // - res.SetX(x*RR); - res.SetY(y*RR); - res.SetZ(z*RR); - res.SetU(u*RR); - res.SetV(v*RR); + res.SetX(myX*RR); + res.SetY(myY*RR); + res.SetZ(myZ*RR); + res.SetU(myU*RR); + res.SetV(myV*RR); return res; } //======================================================================= @@ -261,7 +108,7 @@ IntPolyh_Point IntPolyh_Point::Multiplication(const Standard_Real RR)const //======================================================================= Standard_Real IntPolyh_Point::SquareModulus()const { - Standard_Real res=x*x+y*y+z*z; + Standard_Real res=myX*myX+myY*myY+myZ*myZ; return res; } @@ -271,7 +118,7 @@ Standard_Real IntPolyh_Point::SquareModulus()const //======================================================================= Standard_Real IntPolyh_Point::SquareDistance(const IntPolyh_Point &P2)const { - Standard_Real res=(x-P2.x)*(x-P2.x)+(y-P2.y)*(y-P2.y)+(z-P2.z)*(z-P2.z); + Standard_Real res=(myX-P2.myX)*(myX-P2.myX)+(myY-P2.myY)*(myY-P2.myY)+(myZ-P2.myZ)*(myZ-P2.myZ); return res; } //======================================================================= @@ -280,7 +127,7 @@ Standard_Real IntPolyh_Point::SquareDistance(const IntPolyh_Point &P2)const //======================================================================= Standard_Real IntPolyh_Point::Dot(const IntPolyh_Point &b ) const { - Standard_Real t=x*b.x+y*b.y+z*b.z; + Standard_Real t=myX*b.myX+myY*b.myY+myZ*b.myZ; return t; } //======================================================================= @@ -288,9 +135,9 @@ Standard_Real IntPolyh_Point::Dot(const IntPolyh_Point &b ) const //purpose : //======================================================================= void IntPolyh_Point::Cross(const IntPolyh_Point &a,const IntPolyh_Point &b){ - x=a.y*b.z-a.z*b.y; - y=a.z*b.x-a.x*b.z; - z=a.x*b.y-a.y*b.x; + myX=a.myY*b.myZ-a.myZ*b.myY; + myY=a.myZ*b.myX-a.myX*b.myZ; + myZ=a.myX*b.myY-a.myY*b.myX; } //======================================================================= //function : Dump @@ -298,7 +145,7 @@ void IntPolyh_Point::Cross(const IntPolyh_Point &a,const IntPolyh_Point &b){ //======================================================================= void IntPolyh_Point::Dump() const { - printf("\nPoint : x=%+8.3eg y=%+8.3eg z=%+8.3eg u=%+8.3eg v=%+8.3eg\n",x,y,z,u,v); + printf("\nPoint : x=%+8.3eg y=%+8.3eg z=%+8.3eg u=%+8.3eg v=%+8.3eg\n",myX,myY,myZ,myU,myV); } //======================================================================= //function : Dump @@ -307,29 +154,5 @@ void IntPolyh_Point::Dump() const void IntPolyh_Point::Dump(const Standard_Integer i) const { printf("\nPoint(%3d) : x=%+8.3eg y=%+8.3eg z=%+8.3eg u=%+8.3eg v=%+8.3eg poc=%3d\n", - i,x,y,z,u,v,POC); + i,myX,myY,myZ,myU,myV,myPOC); } -//modified by NIZNHY-PKV Fri Jan 20 12:13:03 2012f -//======================================================================= -//function : SetDegenerated -//purpose : -//======================================================================= -void IntPolyh_Point::SetDegenerated(const Standard_Boolean theFlag) -{ - myDegenerated=theFlag; -} -//======================================================================= -//function : Degenerated -//purpose : -//======================================================================= -Standard_Boolean IntPolyh_Point::Degenerated()const -{ - return myDegenerated; -} - - - - - - - diff --git a/src/IntPolyh/IntPolyh_Point.hxx b/src/IntPolyh/IntPolyh_Point.hxx index 95a4395ab3..0f8903c270 100644 --- a/src/IntPolyh/IntPolyh_Point.hxx +++ b/src/IntPolyh/IntPolyh_Point.hxx @@ -26,121 +26,177 @@ #include class Adaptor3d_HSurface; - - -class IntPolyh_Point +//! The class represents the point on the surface with +//! both 3D and 2D points. +class IntPolyh_Point { public: DEFINE_STANDARD_ALLOC - - Standard_EXPORT IntPolyh_Point(); - - Standard_EXPORT IntPolyh_Point(const Standard_Real xx, const Standard_Real yy, const Standard_Real zz, const Standard_Real uu, const Standard_Real vv); - - Standard_EXPORT Standard_Real X() const; - - Standard_EXPORT Standard_Real Y() const; - - Standard_EXPORT Standard_Real Z() const; - - Standard_EXPORT Standard_Real U() const; - - Standard_EXPORT Standard_Real V() const; - - Standard_EXPORT Standard_Integer PartOfCommon() const; - - Standard_EXPORT void Equal (const IntPolyh_Point& Pt); -void operator = (const IntPolyh_Point& Pt) -{ - Equal(Pt); -} - - Standard_EXPORT void Set (const Standard_Real v1, const Standard_Real v2, const Standard_Real v3, const Standard_Real v4, const Standard_Real v5, const Standard_Integer II = 1); - - Standard_EXPORT void SetX (const Standard_Real v); - - Standard_EXPORT void SetY (const Standard_Real v); - - Standard_EXPORT void SetZ (const Standard_Real v); - - Standard_EXPORT void SetU (const Standard_Real v); - - Standard_EXPORT void SetV (const Standard_Real v); - - Standard_EXPORT void SetPartOfCommon (const Standard_Integer ii); - + //! Constructor + IntPolyh_Point() : + myX(0.), myY(0.), myZ(0.), myU(0.), myV(0.), myPOC(1), myDegenerated(Standard_False) + {} + //! Constructor + IntPolyh_Point(const Standard_Real x, + const Standard_Real y, + const Standard_Real z, + const Standard_Real u, + const Standard_Real v) + : + myX(x), myY(y), myZ(z), myU(u), myV(v), myPOC(1), myDegenerated(Standard_False) + {} + + //! Returns X coordinate of the 3D point + Standard_Real X() const + { + return myX; + } + //! Returns Y coordinate of the 3D point + Standard_Real Y() const + { + return myY; + } + //! Returns the Z coordinate of the 3D point + Standard_Real Z() const + { + return myZ; + } + //! Returns the U coordinate of the 2D point + Standard_Real U() const + { + return myU; + } + //! Returns the V coordinate of the 2D point + Standard_Real V() const + { + return myV; + } + //! Returns 0 if the point is not common with the other surface + Standard_Integer PartOfCommon() const + { + return myPOC; + } + //! Assignment operator + void Equal (const IntPolyh_Point& Pt) + { + myX = Pt.myX; + myY = Pt.myY; + myZ = Pt.myZ; + myU = Pt.myU; + myV = Pt.myV; + } + void operator = (const IntPolyh_Point& Pt) + { + Equal(Pt); + } + //! Sets the point + void Set (const Standard_Real x, + const Standard_Real y, + const Standard_Real z, + const Standard_Real u, + const Standard_Real v, + const Standard_Integer II = 1) + { + myX = x; + myY = y; + myZ = z; + myU = u; + myV = v; + myPOC = II; + } + //! Sets the X coordinate for the 3D point + void SetX (const Standard_Real x) + { + myX = x; + } + //! Sets the Y coordinate for the 3D point + void SetY (const Standard_Real y) + { + myY = y; + } + //! Sets the Z coordinate for the 3D point + void SetZ (const Standard_Real z) + { + myZ = z; + } + //! Sets the U coordinate for the 2D point + void SetU (const Standard_Real u) + { + myU = u; + } + //! Sets the V coordinate for the 2D point + void SetV (const Standard_Real v) + { + myV = v; + } + //! Sets the part of common + void SetPartOfCommon (const Standard_Integer ii) + { + myPOC = ii; + } + //! Creates middle point from P1 and P2 and stores it to this Standard_EXPORT void Middle (const Handle(Adaptor3d_HSurface)& MySurface, const IntPolyh_Point& P1, const IntPolyh_Point& P2); - + //! Addition Standard_EXPORT IntPolyh_Point Add (const IntPolyh_Point& P1) const; -IntPolyh_Point operator + (const IntPolyh_Point& P1) const -{ - return Add(P1); -} - + IntPolyh_Point operator + (const IntPolyh_Point& P1) const + { + return Add(P1); + } + //! Subtraction Standard_EXPORT IntPolyh_Point Sub (const IntPolyh_Point& P1) const; -IntPolyh_Point operator - (const IntPolyh_Point& P1) const -{ - return Sub(P1); -} - + IntPolyh_Point operator - (const IntPolyh_Point& P1) const + { + return Sub(P1); + } + //! Division Standard_EXPORT IntPolyh_Point Divide (const Standard_Real rr) const; -IntPolyh_Point operator / (const Standard_Real rr) const -{ - return Divide(rr); -} - + IntPolyh_Point operator / (const Standard_Real rr) const + { + return Divide(rr); + } + //! Multiplication Standard_EXPORT IntPolyh_Point Multiplication (const Standard_Real rr) const; -IntPolyh_Point operator * (const Standard_Real rr) const -{ - return Multiplication(rr); -} - + IntPolyh_Point operator * (const Standard_Real rr) const + { + return Multiplication(rr); + } + //! Square modulus Standard_EXPORT Standard_Real SquareModulus() const; - + //! Square distance to the other point Standard_EXPORT Standard_Real SquareDistance (const IntPolyh_Point& P2) const; - + //! Dot Standard_EXPORT Standard_Real Dot (const IntPolyh_Point& P2) const; - + //! Cross Standard_EXPORT void Cross (const IntPolyh_Point& P1, const IntPolyh_Point& P2); - + //! Dump Standard_EXPORT void Dump() const; - + //! Dump Standard_EXPORT void Dump (const Standard_Integer i) const; - - Standard_EXPORT void SetDegenerated (const Standard_Boolean theFlag); - - Standard_EXPORT Standard_Boolean Degenerated() const; - - - + //! Sets the degenerated flag + void SetDegenerated (const Standard_Boolean theFlag) + { + myDegenerated = theFlag; + } + //! Returns the degenerated flag + Standard_Boolean Degenerated() const + { + return myDegenerated; + } protected: - - - - private: - - - Standard_Real x; - Standard_Real y; - Standard_Real z; - Standard_Real u; - Standard_Real v; - Standard_Integer POC; + Standard_Real myX; + Standard_Real myY; + Standard_Real myZ; + Standard_Real myU; + Standard_Real myV; + Standard_Integer myPOC; Standard_Boolean myDegenerated; - }; - - - - - - #endif // _IntPolyh_Point_HeaderFile diff --git a/src/IntPolyh/IntPolyh_Triangle.cxx b/src/IntPolyh/IntPolyh_Triangle.cxx index efa78359ba..4308a8c21f 100644 --- a/src/IntPolyh/IntPolyh_Triangle.cxx +++ b/src/IntPolyh/IntPolyh_Triangle.cxx @@ -17,10 +17,8 @@ #include #include -#include #include #include -#include #include #include @@ -57,418 +55,95 @@ static IntPolyh_ArrayOfEdges & TEdges) ; //======================================================================= -//function : IntPolyh_Triangle -//purpose : +//function : ComputeDeflection +//purpose : Computes the deflection of the triangle. +// It is computed as a distance between triangles plane and +// barycenter of the triangle in UV space. //======================================================================= -IntPolyh_Triangle::IntPolyh_Triangle() -: - p1(-1),p2(-1),p3(-1), - e1(-1),oe1(0),e2(-1),oe2(0),e3(-1),oe3(0), - II(0),IP(1),Fleche(0.0) +Standard_Real + IntPolyh_Triangle::ComputeDeflection(const Handle(Adaptor3d_HSurface)& theSurface, + const IntPolyh_ArrayOfPoints& TPoints) { -} -//======================================================================= -//function : IntPolyh_Triangle -//purpose : -//======================================================================= -IntPolyh_Triangle::IntPolyh_Triangle(const Standard_Integer a, - const Standard_Integer b, - const Standard_Integer c) -: - p1(a),p2(b),p3(c), - e1(-1),oe1(0),e2(-1),oe2(0),e3(-1),oe3(0), - II(0),IP(1),Fleche(0.0) -{ -} -//======================================================================= -//function : FirstPoint -//purpose : -//======================================================================= -Standard_Integer IntPolyh_Triangle::FirstPoint() const -{ - return(p1); -} -//======================================================================= -//function : SecondPoint -//purpose : -//======================================================================= -Standard_Integer IntPolyh_Triangle::SecondPoint() const -{ - return(p2); -} -//======================================================================= -//function : ThirdPoint -//purpose : -//======================================================================= -Standard_Integer IntPolyh_Triangle::ThirdPoint() const -{ - return(p3); -} -//======================================================================= -//function : FirstEdge -//purpose : -//======================================================================= -Standard_Integer IntPolyh_Triangle::FirstEdge() const -{ - return(e1); -} -//======================================================================= -//function : FirstEdgeOrientation -//purpose : -//======================================================================= -Standard_Integer IntPolyh_Triangle::FirstEdgeOrientation() const -{ - return(oe1); -} -//======================================================================= -//function : SecondEdge -//purpose : -//======================================================================= -Standard_Integer IntPolyh_Triangle::SecondEdge() const -{ - return(e2); -} -//======================================================================= -//function : SecondEdgeOrientation -//purpose : -//======================================================================= -Standard_Integer IntPolyh_Triangle::SecondEdgeOrientation() const -{ - return(oe2); -} -//======================================================================= -//function : ThirdEdge -//purpose : -//======================================================================= -Standard_Integer IntPolyh_Triangle::ThirdEdge() const -{ - return(e3); -} -//======================================================================= -//function : ThirdEdgeOrientation -//purpose : -//======================================================================= -Standard_Integer IntPolyh_Triangle::ThirdEdgeOrientation() const -{ - return(oe3); -} -//======================================================================= -//function : GetFleche -//purpose : -//======================================================================= -Standard_Real IntPolyh_Triangle::GetFleche() const -{ - return(Fleche); -} -//======================================================================= -//function : IndiceIntersectionPossible -//purpose : -//======================================================================= -Standard_Integer IntPolyh_Triangle::IndiceIntersectionPossible() const -{ - return(IP); -} -//======================================================================= -//function : IndiceIntersection -//purpose : -//======================================================================= -Standard_Integer IntPolyh_Triangle::IndiceIntersection() const -{ - return(II); -} -//======================================================================= -//function : SetFirstPoint -//purpose : -//======================================================================= -void IntPolyh_Triangle::SetFirstPoint(const Standard_Integer a) -{ - p1=a; -} -//======================================================================= -//function : SetSecondPoint -//purpose : -//======================================================================= -void IntPolyh_Triangle::SetSecondPoint(const Standard_Integer b) -{ - p2=b; -} -//======================================================================= -//function : SetThirdPoint -//purpose : -//======================================================================= -void IntPolyh_Triangle::SetThirdPoint(const Standard_Integer c) -{ - p3=c; -} -//======================================================================= -//function : SetFirstEdge -//purpose : -//======================================================================= -void IntPolyh_Triangle::SetFirstEdge(const Standard_Integer e, - const Standard_Integer oe) -{ - e1=e; - oe1=oe; -} -//======================================================================= -//function : SetSecondEdge -//purpose : -//======================================================================= -void IntPolyh_Triangle::SetSecondEdge(const Standard_Integer f, - const Standard_Integer of) -{ - e2=f; - oe2=of; -} -//======================================================================= -//function : SetThirdEdge -//purpose : -//======================================================================= -void IntPolyh_Triangle::SetThirdEdge(const Standard_Integer g, - const Standard_Integer og) -{ - e3=g; - oe3=og; -} -//======================================================================= -//function : SetFleche -//purpose : -//======================================================================= -void IntPolyh_Triangle::SetFleche(const Standard_Real A) -{ - Fleche=A; -} -//======================================================================= -//function : SetIndiceIntersectionPossible -//purpose : -//======================================================================= -void IntPolyh_Triangle::SetIndiceIntersectionPossible(const Standard_Integer I) -{ - IP=I; -} -//======================================================================= -//function : SetIndiceIntersection -//purpose : -//======================================================================= -void IntPolyh_Triangle::SetIndiceIntersection(const Standard_Integer I) -{ - II=I; -} -//======================================================================= -//function : GetEdgeNumber -//purpose : -//======================================================================= -Standard_Integer - IntPolyh_Triangle::GetEdgeNumber(const Standard_Integer EdgeIndex) const -{ - if(EdgeIndex==1) - return(e1); - if(EdgeIndex==2) - return(e2); - if(EdgeIndex==3) - return(e3); - - return 0; -} -//======================================================================= -//function : SetEdge -//purpose : -//======================================================================= -void IntPolyh_Triangle::SetEdge(const Standard_Integer EdgeIndex, - const Standard_Integer EdgeNumber) -{ - if(EdgeIndex==1) - e1=EdgeNumber; - if(EdgeIndex==2) - e2=EdgeNumber; - if(EdgeIndex==3) - e3=EdgeNumber; -} -//======================================================================= -//function : GetEdgeOrientation -//purpose : -//======================================================================= -Standard_Integer - IntPolyh_Triangle::GetEdgeOrientation(const Standard_Integer EdgeIndex) const -{ - if(EdgeIndex==1) - return(oe1); - if(EdgeIndex==2) - return(oe2); - if(EdgeIndex==3) - return(oe3); - - return 0; - -} -//======================================================================= -//function : SetEdgeOrientation -//purpose : -//======================================================================= -void IntPolyh_Triangle::SetEdgeOrientation(const Standard_Integer EdgeIndex, - const Standard_Integer OrEd) -{ - if(EdgeIndex==1) - oe1=OrEd; - if(EdgeIndex==2) - oe2=OrEd; - if(EdgeIndex==3) - oe3=OrEd; -} - - -//======================================================================= -//function : TriangleDeflection -//purpose : -/*Calcul de la fleche pour un triangle************** - Distance entre le plan forme par le triangle et - le barycentre situe sur la surface calcule avec les coordonnees Gu,Gv - (coordonnees du barycentre du triangle dans l'espace UV)*/ -//======================================================================= -void IntPolyh_Triangle::TriangleDeflection(const Handle(Adaptor3d_HSurface)& MySurface, - const IntPolyh_ArrayOfPoints& TPoints) -{ - const IntPolyh_Point & P1 = TPoints[p1]; - const IntPolyh_Point & P2 = TPoints[p2]; - const IntPolyh_Point & P3 = TPoints[p3]; + myDeflection = 0.; + // + const IntPolyh_Point & P1 = TPoints[myPoints[0]]; + const IntPolyh_Point & P2 = TPoints[myPoints[1]]; + const IntPolyh_Point & P3 = TPoints[myPoints[2]]; // - //modified by NIZNHY-PKV Fri Jan 20 14:25:11 2012f { - Standard_Integer iDeg1, iDeg2, iDeg3, iDeg; - // - iDeg1=(P1.Degenerated()) ? 1 : 0; - iDeg2=(P2.Degenerated()) ? 1 : 0; - iDeg3=(P3.Degenerated()) ? 1 : 0; - iDeg=iDeg1+iDeg2+iDeg3; - if (iDeg>1) { - Fleche=0.; - return; + // check if the triangle is not degenerated - no more than one point + // has a degenerated flag + Standard_Integer iDeg = (P1.Degenerated() ? 1 : 0) + + (P2.Degenerated() ? 1 : 0) + + (P3.Degenerated() ? 1 : 0); + if (iDeg > 1) { + myIsDegenerated = Standard_True; + return myDeflection; } } - //modified by NIZNHY-PKV Fri Jan 20 14:25:13 2012t - Standard_Real Gu, Gv, SqNorme; - gp_Pnt PtXYZ; // - Gu=(P1.U()+P2.U()+P3.U())/3.0; - Gv=(P1.V()+P2.V()+P3.V())/3.0; - - PtXYZ = (MySurface)->Value( Gu, Gv); - IntPolyh_Point BarycentreReel(PtXYZ.X(), PtXYZ.Y(), PtXYZ.Z(), Gu, Gv); + // Plane of the triangle IntPolyh_Point NormaleTri; NormaleTri.Cross(P2-P1,P3-P1); - SqNorme=NormaleTri.SquareModulus(); - - if (SqNorme > SquareMyConfusionPrecision) { - NormaleTri=NormaleTri/sqrt(SqNorme); - Fleche=Abs(NormaleTri.Dot( BarycentreReel-P1)); + Standard_Real SqNorm = NormaleTri.SquareModulus(); + if (SqNorm < SquareMyConfusionPrecision) { + // The triangle is degenerated + myIsDegenerated = Standard_True; + return myDeflection; } - else { - // On calcule la fleche sur le plus grand des edges - // calcul des longueurs des cotes au carre - Standard_Real L12 = P1.SquareDistance(P2); - Standard_Real L23 = P2.SquareDistance(P3); - Standard_Real L31 = P3.SquareDistance(P1); - - IntPolyh_Point Milieu; // milieu du plus grand des edges - - if ((L12>L23) && (L12>L31)) - Milieu.Middle( MySurface,P1, P2); - else if ((L23>L31) && (L23>L12)) - Milieu.Middle( MySurface,P2, P3); - else if ((L31>L12) && (L31>L23)) - Milieu.Middle( MySurface,P3, P1); - - - gp_Pnt PtXYZMilieu = (MySurface)->Value( Milieu.U(), Milieu.V()); - IntPolyh_Point MilieuReel(PtXYZMilieu.X(), PtXYZMilieu.Y(), PtXYZMilieu.Z(), Milieu.U(), Milieu.V()); - Fleche = sqrt(Milieu.SquareDistance(MilieuReel)); - } + // + // Compute point on the surface + Standard_Real Gu=(P1.U()+P2.U()+P3.U())/3.0; + Standard_Real Gv=(P1.V()+P2.V()+P3.V())/3.0; + gp_Pnt PtXYZ = theSurface->Value( Gu, Gv); + // Point on the surface + IntPolyh_Point BarycentreReel(PtXYZ.X(), PtXYZ.Y(), PtXYZ.Z(), Gu, Gv); + // compute distance to plane + NormaleTri = NormaleTri / sqrt(SqNorm); + myDeflection = Abs(NormaleTri.Dot(BarycentreReel - P1)); + return myDeflection; } //======================================================================= -//function : CheckCommonEdge +//function : GetNextTriangle //purpose : //======================================================================= -Standard_Integer - IntPolyh_Triangle::CheckCommonEdge(const Standard_Integer PT1, - const Standard_Integer PT2, - const Standard_Integer PT3, - const Standard_Integer Index, - const IntPolyh_ArrayOfTriangles &TTriangles) const +Standard_Integer + IntPolyh_Triangle::GetNextTriangle(const Standard_Integer theTriangle, + const Standard_Integer theEdgeNum, + const IntPolyh_ArrayOfEdges& TEdges) const { - Standard_Integer P1,P2,P3,res=-1; - P1=TTriangles[Index].FirstPoint(); - P2=TTriangles[Index].SecondPoint(); - P3=TTriangles[Index].ThirdPoint(); - - if ( (P1==PT1)||(P1==PT2) ) { - if ( ( (P2==PT1)||(P2==PT2) )&&(P3!=PT3) ) res = Index; //edge commun P1P2 - else if ( ( (P3==PT1)||(P3==PT2) )&&(P2!=PT3) ) res = Index;//edge commun P1P3 + Standard_Integer aNextTriangle = -1; + if (theEdgeNum < 1 || theEdgeNum > 3) { + return aNextTriangle; } - else if ( (P2==PT1)||(P2==PT2) ) { - if ( ( (P3==PT1)||(P3==PT2) )&&(P1!=PT3) ) res = Index; //edge commun P2P3 - } - else res=-1; - return(res); + // + const IntPolyh_Edge & anEdge = TEdges[myEdges[theEdgeNum-1]]; + aNextTriangle = ((anEdge.FirstTriangle() == theTriangle) ? + anEdge.SecondTriangle() : anEdge.FirstTriangle()); + return aNextTriangle; } -//======================================================================= -//function : GetNextTriangle2 -//purpose : -//======================================================================= -Standard_Integer - IntPolyh_Triangle::GetNextTriangle2(const Standard_Integer NumTri, - const Standard_Integer NumEdge, - const IntPolyh_ArrayOfEdges &TEdges) const -{ - Standard_Integer NumNextTri=-1; - if (NumEdge==1) { - const IntPolyh_Edge & Edge1=TEdges[e1]; - if(Edge1.FirstTriangle()==NumTri) - NumNextTri=Edge1.SecondTriangle(); - else - NumNextTri=Edge1.FirstTriangle(); - } - else if (NumEdge==2) { - const IntPolyh_Edge & Edge2=TEdges[e2]; - if(Edge2.FirstTriangle()==NumTri) - NumNextTri=Edge2.SecondTriangle(); - else - NumNextTri=Edge2.FirstTriangle(); - } - else if (NumEdge==3) { - const IntPolyh_Edge & Edge3=TEdges[e3]; - if(Edge3.FirstTriangle()==NumTri) - NumNextTri=Edge3.SecondTriangle(); - else - NumNextTri=Edge3.FirstTriangle(); - } - return (NumNextTri); -} - //======================================================================= //function : LinkEdges2Triangle //purpose : //======================================================================= -void IntPolyh_Triangle::LinkEdges2Triangle(const IntPolyh_ArrayOfEdges & TEdges, - const Standard_Integer edge1, - const Standard_Integer edge2, - const Standard_Integer edge3) { - if( (edge1<0)||(edge2<0)||(edge3<0) ) { - - } - else { - e1=edge1; - e2=edge2; - e3=edge3; - - if(TEdges[e1].FirstPoint()==p1) oe1=1; - else oe1=-1; - if(TEdges[e2].FirstPoint()==p2) oe2=1; - else oe2=-1; - if(TEdges[e3].FirstPoint()==p3) oe3=1; - else oe3=-1; +void IntPolyh_Triangle::LinkEdges2Triangle(const IntPolyh_ArrayOfEdges& TEdges, + const Standard_Integer theEdge1, + const Standard_Integer theEdge2, + const Standard_Integer theEdge3) +{ + if (theEdge1 < 0 || theEdge2 < 0 || theEdge3 < 0) { + return; } + // + myEdges[0] = theEdge1; + myEdges[1] = theEdge2; + myEdges[2] = theEdge3; + // + myEdgesOrientations[0] = ((TEdges[myEdges[0]].FirstPoint() == myPoints[0]) ? 1 : -1); + myEdgesOrientations[1] = ((TEdges[myEdges[1]].FirstPoint() == myPoints[1]) ? 1 : -1); + myEdgesOrientations[2] = ((TEdges[myEdges[2]].FirstPoint() == myPoints[2]) ? 1 : -1); } //======================================================================= @@ -549,7 +224,7 @@ void NewTriangle(const Standard_Integer P1, TTriangles[FinTT].SetFirstPoint(P1); TTriangles[FinTT].SetSecondPoint(P2); TTriangles[FinTT].SetThirdPoint(P3); - TTriangles[FinTT].TriangleDeflection(MySurface, TPoints); + TTriangles[FinTT].ComputeDeflection(MySurface, TPoints); TTriangles.IncrementNbItems(); } @@ -595,27 +270,25 @@ void OldEdge(const Standard_Integer EdgeN, //purpose : //======================================================================= void IntPolyh_Triangle::MiddleRefinement(const Standard_Integer NumTri, - const Handle(Adaptor3d_HSurface)& MySurface, - IntPolyh_ArrayOfPoints &TPoints, - IntPolyh_ArrayOfTriangles &TTriangles, - IntPolyh_ArrayOfEdges & TEdges) { + const Handle(Adaptor3d_HSurface)& MySurface, + IntPolyh_ArrayOfPoints &TPoints, + IntPolyh_ArrayOfTriangles &TTriangles, + IntPolyh_ArrayOfEdges & TEdges) +{ Standard_Integer FinTE = TEdges.NbItems(); Standard_Integer FinTT = TTriangles.NbItems(); - - ///Raffinage de la maille et de ses voisines par le milieu du plus grand des cotes + // Refinement of the mesh by the middle of the largest dimensions Standard_Integer numP1 = FirstPoint(); Standard_Integer numP2 = SecondPoint(); Standard_Integer numP3 = ThirdPoint(); - IntPolyh_Point P1 = TPoints[numP1]; - IntPolyh_Point P2 = TPoints[numP2]; - IntPolyh_Point P3 = TPoints[numP3]; + const IntPolyh_Point& P1 = TPoints[numP1]; + const IntPolyh_Point& P2 = TPoints[numP2]; + const IntPolyh_Point& P3 = TPoints[numP3]; - - ///calcul des longueurs des cotes au carre - + // compute the largest dimension Standard_Real L12 = P1.SquareDistance(P2); Standard_Real L23 = P2.SquareDistance(P3); Standard_Real L31 = P3.SquareDistance(P1); @@ -636,7 +309,7 @@ void IntPolyh_Triangle::MiddleRefinement(const Standard_Integer NumTri, ///***AFFINAGE DU TRIANGLE ADJACENT*** - Standard_Integer numTA = GetNextTriangle2(NumTri,1,TEdges); + Standard_Integer numTA = GetNextTriangle(NumTri,1,TEdges); if (numTA>=0) { Standard_Integer numP3b = -1; @@ -669,20 +342,20 @@ void IntPolyh_Triangle::MiddleRefinement(const Standard_Integer NumTri, NewEdge(FinTP,numP3b,T3,T4,TEdges); ///On met a jour les anciens edges - OldEdge(e2,NumTri,T1,TEdges); - OldEdge(e3,NumTri,T2,TEdges); + OldEdge(myEdges[1],NumTri,T1,TEdges); + OldEdge(myEdges[2],NumTri,T2,TEdges); OldEdge(Edge2b,numTA,T3,TEdges); OldEdge(Edge3b,numTA,T4,TEdges); /// On remplit les nouveaux triangles avec les edges - TTriangles[T1].LinkEdges2Triangle(TEdges,e2,E3,E2); - TTriangles[T2].LinkEdges2Triangle(TEdges,e3,E1,E3); + TTriangles[T1].LinkEdges2Triangle(TEdges,myEdges[1],E3,E2); + TTriangles[T2].LinkEdges2Triangle(TEdges,myEdges[2],E1,E3); TTriangles[T3].LinkEdges2Triangle(TEdges,Edge2b,E4,E2); TTriangles[T4].LinkEdges2Triangle(TEdges,Edge3b,E1,E4); ///On tue le triangle adjacent - TTriangles[numTA].Fleche=-1.0; - TTriangles[numTA].IP=0; + TTriangles[numTA].SetDeflection(-1.0); + TTriangles[numTA].SetIntersectionPossible(Standard_False); } else { ///seulement deux nouveaux triangles @@ -699,12 +372,12 @@ void IntPolyh_Triangle::MiddleRefinement(const Standard_Integer NumTri, NewEdge(FinTP,numP3,T1,T2,TEdges); ///On met a jour les anciens edges - OldEdge(e2,NumTri,T1,TEdges); - OldEdge(e3,NumTri,T2,TEdges); + OldEdge(myEdges[1],NumTri,T1,TEdges); + OldEdge(myEdges[2],NumTri,T2,TEdges); /// On remplit les nouveaux triangles avec les edges - TTriangles[T1].LinkEdges2Triangle(TEdges,e2,E3,E2); - TTriangles[T2].LinkEdges2Triangle(TEdges,e3,E1,E3); + TTriangles[T1].LinkEdges2Triangle(TEdges,myEdges[1],E3,E2); + TTriangles[T2].LinkEdges2Triangle(TEdges,myEdges[2],E1,E3); } } @@ -724,7 +397,7 @@ void IntPolyh_Triangle::MiddleRefinement(const Standard_Integer NumTri, ///*RAFFINAGE DU TRIANGLE ADJACENT*** - Standard_Integer numTA = GetNextTriangle2(NumTri,2,TEdges); + Standard_Integer numTA = GetNextTriangle(NumTri,2,TEdges); if (numTA>=0) { Standard_Integer numP1b=-1; @@ -757,20 +430,20 @@ void IntPolyh_Triangle::MiddleRefinement(const Standard_Integer NumTri, NewEdge(FinTP,numP1b,T3,T4,TEdges); ///On met a jour les anciens edges - OldEdge(e1,NumTri,T1,TEdges); - OldEdge(e3,NumTri,T2,TEdges); + OldEdge(myEdges[0],NumTri,T1,TEdges); + OldEdge(myEdges[2],NumTri,T2,TEdges); OldEdge(Edge1b,numTA,T3,TEdges); OldEdge(Edge3b,numTA,T4,TEdges); /// On remplit les nouveaux triangles avec les edges - TTriangles[T1].LinkEdges2Triangle(TEdges,e1,E1,E3); - TTriangles[T2].LinkEdges2Triangle(TEdges,e3,E3,E2); + TTriangles[T1].LinkEdges2Triangle(TEdges,myEdges[0],E1,E3); + TTriangles[T2].LinkEdges2Triangle(TEdges,myEdges[2],E3,E2); TTriangles[T3].LinkEdges2Triangle(TEdges,Edge1b,E4,E1); TTriangles[T4].LinkEdges2Triangle(TEdges,Edge3b,E2,E4); ///On tue le triangle adjacent - TTriangles[numTA].Fleche=-1.0; - TTriangles[numTA].IP=0; + TTriangles[numTA].SetDeflection(-1.0); + TTriangles[numTA].SetIntersectionPossible(Standard_False); } else { ///seulement deux nouveaux triangles ///Nouveaux Edges @@ -786,12 +459,12 @@ void IntPolyh_Triangle::MiddleRefinement(const Standard_Integer NumTri, NewEdge(FinTP,numP1,T1,T2,TEdges); ///On met a jour les anciens edges - OldEdge(e1,NumTri,T1,TEdges); - OldEdge(e3,NumTri,T2,TEdges); + OldEdge(myEdges[0],NumTri,T1,TEdges); + OldEdge(myEdges[2],NumTri,T2,TEdges); /// On remplit les nouveaux triangles avec les edges - TTriangles[T1].LinkEdges2Triangle(TEdges,e1,E1,E3); - TTriangles[T2].LinkEdges2Triangle(TEdges,e3,E3,E2); + TTriangles[T1].LinkEdges2Triangle(TEdges,myEdges[0],E1,E3); + TTriangles[T2].LinkEdges2Triangle(TEdges,myEdges[2],E3,E2); } } else { @@ -809,7 +482,7 @@ void IntPolyh_Triangle::MiddleRefinement(const Standard_Integer NumTri, ///*RAFFINAGE DU TRIANGLE ADJACENT*** - Standard_Integer numTA = GetNextTriangle2(NumTri,3,TEdges); + Standard_Integer numTA = GetNextTriangle(NumTri,3,TEdges); if (numTA>=0) { @@ -843,20 +516,20 @@ void IntPolyh_Triangle::MiddleRefinement(const Standard_Integer NumTri, NewEdge(FinTP,numP1,T1,T3,TEdges); ///On met a jour les anciens edges - OldEdge(e1,NumTri,T1,TEdges); - OldEdge(e2,NumTri,T2,TEdges); + OldEdge(myEdges[0],NumTri,T1,TEdges); + OldEdge(myEdges[1],NumTri,T2,TEdges); OldEdge(Edge1b,numTA,T3,TEdges); OldEdge(Edge2b,numTA,T4,TEdges); /// On remplit les nouveaux triangles avec les edges - TTriangles[T1].LinkEdges2Triangle(TEdges,e1,E1,E4); - TTriangles[T2].LinkEdges2Triangle(TEdges,e2,E2,E1); + TTriangles[T1].LinkEdges2Triangle(TEdges,myEdges[0],E1,E4); + TTriangles[T2].LinkEdges2Triangle(TEdges,myEdges[1],E2,E1); TTriangles[T3].LinkEdges2Triangle(TEdges,Edge1b,E3,E4); TTriangles[T4].LinkEdges2Triangle(TEdges,Edge2b,E2,E3); ///On tue le triangle adjacent - TTriangles[numTA].Fleche=-1.0; - TTriangles[numTA].IP=0; + TTriangles[numTA].SetDeflection(-1.0); + TTriangles[numTA].SetIntersectionPossible(Standard_False); } else { ///seulement deux nouveaux triangles ///Nouveaux Edges @@ -872,197 +545,113 @@ void IntPolyh_Triangle::MiddleRefinement(const Standard_Integer NumTri, NewEdge(FinTP,numP1,T1,-1,TEdges); ///On met a jour les anciens edges - OldEdge(e1,NumTri,T1,TEdges); - OldEdge(e2,NumTri,T2,TEdges); + OldEdge(myEdges[0],NumTri,T1,TEdges); + OldEdge(myEdges[1],NumTri,T2,TEdges); /// On remplit les nouveaux triangles avec les edges - TTriangles[T1].LinkEdges2Triangle(TEdges,e1,E1,E4); - TTriangles[T2].LinkEdges2Triangle(TEdges,e2,E2,E1); + TTriangles[T1].LinkEdges2Triangle(TEdges,myEdges[0],E1,E4); + TTriangles[T2].LinkEdges2Triangle(TEdges,myEdges[1],E2,E1); } } - /// Le triangle traite est maintenant obsolete - ///***On tue le triangle*** - Fleche=-1.0; - IP=0; - TPoints.IncrementNbItems(); + + // make the triangle obsolete + myDeflection = -1.0; + myIsIntersectionPossible = Standard_False; } //======================================================================= //function : MultipleMiddleRefinement //purpose : //======================================================================= -void IntPolyh_Triangle::MultipleMiddleRefinement(const Standard_Integer NbAffinages, - const Standard_Integer NumTri, - const Handle(Adaptor3d_HSurface)& MySurface, - IntPolyh_ArrayOfPoints &TPoints, - IntPolyh_ArrayOfTriangles &TTriangles, - IntPolyh_ArrayOfEdges & TEdges) { - +void IntPolyh_Triangle::MultipleMiddleRefinement(const Standard_Real theRefineCriterion, + const Bnd_Box& theBox, + const Standard_Integer theTriangleNumber, + const Handle(Adaptor3d_HSurface)& theSurface, + IntPolyh_ArrayOfPoints& TPoints, + IntPolyh_ArrayOfTriangles& TTriangles, + IntPolyh_ArrayOfEdges& TEdges) +{ + // Number of triangles before refinement of current triangle const Standard_Integer FinTTInit = TTriangles.NbItems(); - - //On sait qu'il faut affiner au moins une fois - TTriangles[NumTri].MiddleRefinement(NumTri,MySurface,TPoints, - TTriangles,TEdges); - - if (NbAffinages>1) { - Standard_Integer MyNbAffinages=0; - if (NbAffinages > 5) - MyNbAffinages = 4;//5 est le maximum et on a deja affine une fois - //On a decide d'arreter a 5 car avec un triangle on peut en obtenir 1024 - else MyNbAffinages = NbAffinages-1;//dans tous les cas MyNbAffinages>0 - - - //Un affinage peut donner deux ou quatre nouveaux triangles - // ils seront ajoute a la fin du tableau de triangles, et auront comme indice - // FinTTInit, FinTTInit+1,... - - - Standard_Integer NombreReelsAffinages = 4; - for(Standard_Integer iii=1; iii CritereAffinage) - TriangleCourant.MiddleRefinement(iii,MySurface,TPoints, - TTriangles,TEdges); - - if ( FinTT > CritereArret )//critere d'arret 250 nouveaux triangles - iii = FinTT; - } -} - -//======================================================================= -//function : SetEdgeandOrientation -//purpose : -//======================================================================= -void IntPolyh_Triangle::SetEdgeandOrientation(const Standard_Integer EdgeIndex, - const IntPolyh_ArrayOfEdges &TEdges) { - const Standard_Integer FinTE = TEdges.NbItems(); - - Standard_Integer PE1 =0,PE2 =0; - - Standard_Integer Test=1; - - if (EdgeIndex==1) { PE1=p1; PE2=p2; } - else if (EdgeIndex==2) { PE1=p2; PE2=p3; } - else if (EdgeIndex==3) { PE1=p3; PE2=p1; } - else { - Test=0; - } - if (Test!=0) { - for(Standard_Integer iioo=0; iioo theRefineCriterion) { + aTriangle.MiddleRefinement(i, theSurface, TPoints, TTriangles, TEdges); } } } +//======================================================================= +//function : SetEdgeAndOrientation +//purpose : +//======================================================================= +void IntPolyh_Triangle::SetEdgeAndOrientation(const IntPolyh_Edge& theEdge, + const Standard_Integer theEdgeIndex) +{ + // Points on the edge - pe1, pe2 + Standard_Integer pe1 = theEdge.FirstPoint(), pe2 = theEdge.SecondPoint(); + // + // We have points on the triangle - p1, p2 and p3; + // And points on the edge - pe1, pe2; + // By comparing these points we should define which + // edge it is for the triangle and its orientation on it: + // e1 = p1->p2; + // e2 = p2->p3; + // e3 = p3->p1; + // In case the order of points on the edge is forward, + // the orientation is positive, otherwise it is negative. + for (Standard_Integer i = 0, i1 = 1; i < 3; ++i, ++i1) { + if (i1 > 2) { + i1 = 0; + } + // + if (pe1 == myPoints[i] && pe2 == myPoints[i1]) { + myEdges[i] = theEdgeIndex; + myEdgesOrientations[i] = 1; + break; + } + if (pe1 == myPoints[i1] && pe2 == myPoints[i]) { + myEdges[i] = theEdgeIndex; + myEdgesOrientations[i] = -1; + break; + } + } +} + +//======================================================================= +//function : BoundingBox +//purpose : +//======================================================================= +const Bnd_Box& IntPolyh_Triangle::BoundingBox(const IntPolyh_ArrayOfPoints& thePoints) +{ + if (myBox.IsVoid()) { + const IntPolyh_Point& aP1 = thePoints[myPoints[0]]; + const IntPolyh_Point& aP2 = thePoints[myPoints[1]]; + const IntPolyh_Point& aP3 = thePoints[myPoints[2]]; + myBox.Add(gp_Pnt(aP1.X(), aP1.Y(), aP1.Z())); + myBox.Add(gp_Pnt(aP2.X(), aP2.Y(), aP2.Z())); + myBox.Add(gp_Pnt(aP3.X(), aP3.Y(), aP3.Z())); + myBox.SetGap(myDeflection + Precision::Confusion()); + } + return myBox; +} //======================================================================= //function : Dump //purpose : //======================================================================= void IntPolyh_Triangle::Dump (const Standard_Integer i) const { - printf("\nTriangle(%3d) : Points %5d %5d %5d Edges %5d %5d %5d fleche: %8f intersection possible %8d intersection: %5d\n" - ,i,p1,p2,p3,e1,e2,e3,Fleche,IP,II); + printf("\nTriangle(%3d) : Points %5d %5d %5d Edges %5d %5d %5d deflection: %8f " + "intersection possible %8d intersection: %5d\n", + i, myPoints[0], myPoints[1], myPoints[2], + myEdges[0], myEdges[1], myEdges[2], + myDeflection, (myIsIntersectionPossible ? 1 : 0), (myHasIntersection ? 1 : 0)); } - - -//======================================================================= -//function : DumpFleche -//purpose : -//======================================================================= -void IntPolyh_Triangle::DumpFleche (const Standard_Integer i) const { - printf("\nTriangle(%3d) fleche: %5f\n",i,Fleche); -} - diff --git a/src/IntPolyh/IntPolyh_Triangle.hxx b/src/IntPolyh/IntPolyh_Triangle.hxx index 27769c538a..f27e924b93 100644 --- a/src/IntPolyh/IntPolyh_Triangle.hxx +++ b/src/IntPolyh/IntPolyh_Triangle.hxx @@ -23,134 +23,264 @@ #include #include +#include #include #include #include -#include class Adaptor3d_HSurface; -class Bnd_Box; class IntPolyh_StartPoint; - - +//! The class represents the triangle built from three IntPolyh points +//! and three IntPolyh edges. class IntPolyh_Triangle { public: DEFINE_STANDARD_ALLOC - - Standard_EXPORT IntPolyh_Triangle(); - - Standard_EXPORT IntPolyh_Triangle(const Standard_Integer i1, const Standard_Integer i2, const Standard_Integer i3); - - Standard_EXPORT Standard_Integer FirstPoint() const; - - Standard_EXPORT Standard_Integer SecondPoint() const; - - Standard_EXPORT Standard_Integer ThirdPoint() const; - - Standard_EXPORT Standard_Integer FirstEdge() const; - - Standard_EXPORT Standard_Integer FirstEdgeOrientation() const; - - Standard_EXPORT Standard_Integer SecondEdge() const; - - Standard_EXPORT Standard_Integer SecondEdgeOrientation() const; - - Standard_EXPORT Standard_Integer ThirdEdge() const; - - Standard_EXPORT Standard_Integer ThirdEdgeOrientation() const; - - Standard_EXPORT Standard_Real GetFleche() const; - - Standard_EXPORT Standard_Integer IndiceIntersectionPossible() const; - - Standard_EXPORT Standard_Integer IndiceIntersection() const; - - Standard_EXPORT void SetFirstPoint (const Standard_Integer v); - - Standard_EXPORT void SetSecondPoint (const Standard_Integer v); - - Standard_EXPORT void SetThirdPoint (const Standard_Integer v); - - Standard_EXPORT void SetFirstEdge (const Standard_Integer v, const Standard_Integer s); - - Standard_EXPORT void SetSecondEdge (const Standard_Integer v, const Standard_Integer s); - - Standard_EXPORT void SetThirdEdge (const Standard_Integer v, const Standard_Integer s); - - Standard_EXPORT void SetFleche (const Standard_Real v); - - Standard_EXPORT void SetIndiceIntersectionPossible (const Standard_Integer v); - - Standard_EXPORT void SetIndiceIntersection (const Standard_Integer v); - - Standard_EXPORT Standard_Integer GetEdgeNumber (const Standard_Integer v) const; - - Standard_EXPORT void SetEdge (const Standard_Integer v, const Standard_Integer en); - - Standard_EXPORT Standard_Integer GetEdgeOrientation (const Standard_Integer v) const; - - Standard_EXPORT void SetEdgeOrientation (const Standard_Integer v, const Standard_Integer oe); - - Standard_EXPORT void TriangleDeflection (const Handle(Adaptor3d_HSurface)& MaSurface, const IntPolyh_ArrayOfPoints& TP); - - Standard_EXPORT Standard_Integer CheckCommonEdge (const Standard_Integer PE1, const Standard_Integer PE2, const Standard_Integer P3, const Standard_Integer Index, const IntPolyh_ArrayOfTriangles& TTriangles) const; - - Standard_EXPORT Standard_Integer GetNextTriangle2 (const Standard_Integer NumTri, const Standard_Integer NumEdge, const IntPolyh_ArrayOfEdges& TEdges) const; - - Standard_EXPORT void MiddleRefinement (const Standard_Integer TriangleNumber, const Handle(Adaptor3d_HSurface)& MySurface, IntPolyh_ArrayOfPoints& TPoints, IntPolyh_ArrayOfTriangles& TTriangles, IntPolyh_ArrayOfEdges& TEdges); - - Standard_EXPORT void MultipleMiddleRefinement (const Standard_Integer NombreAffinages, const Standard_Integer TriangleNumber, const Handle(Adaptor3d_HSurface)& MySurface, IntPolyh_ArrayOfPoints& TPoints, IntPolyh_ArrayOfTriangles& TTriangles, IntPolyh_ArrayOfEdges& TEdges); - - Standard_EXPORT Standard_Integer CompareBoxTriangle (const Bnd_Box& b, const IntPolyh_ArrayOfPoints& TPoints) const; - - Standard_EXPORT void MultipleMiddleRefinement2 (const Standard_Real RefineCriterion, const Bnd_Box& thebox, const Standard_Integer TriangleNumber, const Handle(Adaptor3d_HSurface)& MySurface, IntPolyh_ArrayOfPoints& TPoints, IntPolyh_ArrayOfTriangles& TTriangles, IntPolyh_ArrayOfEdges& TEdges); - - Standard_EXPORT Standard_Integer GetNextChainTriangle (const IntPolyh_StartPoint& SPIni, const Standard_Integer LastTTC, IntPolyh_ArrayOfCouples& TriContactsArray, const IntPolyh_ArrayOfTriangles& TTriangles1, const IntPolyh_ArrayOfTriangles& TTriangles2, Standard_Integer& NumContact, Standard_Integer& NextTriangle) const; - - Standard_EXPORT void LinkEdges2Triangle (const IntPolyh_ArrayOfEdges& TEdges, const Standard_Integer ed1, const Standard_Integer ed2, const Standard_Integer ed3); - - Standard_EXPORT void SetEdgeandOrientation (const Standard_Integer Edge, const IntPolyh_ArrayOfEdges& TEdges); - + //! Constructor + IntPolyh_Triangle() : + myHasIntersection(Standard_False), + myIsIntersectionPossible(Standard_True), + myIsDegenerated(Standard_False), + myDeflection(0.0) + { + myPoints[0] = -1; + myPoints[1] = -1; + myPoints[2] = -1; + myEdges[0] = -1; + myEdges[1] = -1; + myEdges[2] = -1; + myEdgesOrientations[0] = 0; + myEdgesOrientations[1] = 0; + myEdgesOrientations[2] = 0; + } + + //! Constructor + IntPolyh_Triangle(const Standard_Integer thePoint1, + const Standard_Integer thePoint2, + const Standard_Integer thePoint3) + : + myHasIntersection(Standard_False), + myIsIntersectionPossible(Standard_True), + myIsDegenerated(Standard_False), + myDeflection(0.0) + { + myPoints[0] = thePoint1; + myPoints[1] = thePoint2; + myPoints[2] = thePoint3; + myEdges[0] = -1; + myEdges[1] = -1; + myEdges[2] = -1; + myEdgesOrientations[0] = 0; + myEdgesOrientations[1] = 0; + myEdgesOrientations[2] = 0; + } + + //! Returns the first point + Standard_Integer FirstPoint() const + { + return myPoints[0]; + } + //! Returns the second point + Standard_Integer SecondPoint() const + { + return myPoints[1]; + } + //! Returns the third point + Standard_Integer ThirdPoint() const + { + return myPoints[2]; + } + //! Returns the first edge + Standard_Integer FirstEdge() const + { + return myEdges[0]; + } + //! Returns the orientation of the first edge + Standard_Integer FirstEdgeOrientation() const + { + return myEdgesOrientations[0]; + } + //! Returns the second edge + Standard_Integer SecondEdge() const + { + return myEdges[1]; + } + //! Returns the orientation of the second edge + Standard_Integer SecondEdgeOrientation() const + { + return myEdgesOrientations[1]; + } + //! Returns the third edge + Standard_Integer ThirdEdge() const + { + return myEdges[2]; + } + //! Returns the orientation of the third edge + Standard_Integer ThirdEdgeOrientation() const + { + return myEdgesOrientations[2]; + } + //! Returns the deflection of the triangle + Standard_Real Deflection() const + { + return myDeflection; + } + //! Returns possibility of the intersection + Standard_Boolean IsIntersectionPossible() const + { + return myIsIntersectionPossible; + } + //! Returns true if the triangle has interfered the other triangle + Standard_Boolean HasIntersection() const + { + return myHasIntersection; + } + //! Returns the Degenerated flag + Standard_Boolean IsDegenerated() const + { + return myIsDegenerated; + } + //! Sets the first point + void SetFirstPoint(const Standard_Integer thePoint) + { + myPoints[0] = thePoint; + } + //! Sets the second point + void SetSecondPoint(const Standard_Integer thePoint) + { + myPoints[1] = thePoint; + } + //! Sets the third point + void SetThirdPoint(const Standard_Integer thePoint) + { + myPoints[2] = thePoint; + } + //! Sets the first edge + void SetFirstEdge(const Standard_Integer theEdge, + const Standard_Integer theEdgeOrientation) + { + myEdges[0] = theEdge; + myEdgesOrientations[0] = theEdgeOrientation; + } + //! Sets the second edge + void SetSecondEdge(const Standard_Integer theEdge, + const Standard_Integer theEdgeOrientation) + { + myEdges[1] = theEdge; + myEdgesOrientations[1] = theEdgeOrientation; + } + //! Sets the third edge + void SetThirdEdge(const Standard_Integer theEdge, + const Standard_Integer theEdgeOrientation) + { + myEdges[2] = theEdge; + myEdgesOrientations[2] = theEdgeOrientation; + } + //! Sets the deflection + void SetDeflection(const Standard_Real theDeflection) + { + myDeflection = theDeflection; + } + //! Sets the flag of possibility of intersection + void SetIntersectionPossible(const Standard_Boolean theIP) + { + myIsIntersectionPossible = theIP; + } + //! Sets the flag of intersection + void SetIntersection(const Standard_Boolean theInt) + { + myHasIntersection = theInt; + } + //! Sets the degenerated flag + void SetDegenerated(const Standard_Boolean theDegFlag) + { + myIsDegenerated = theDegFlag; + } + //! Gets the edge number by the index + Standard_Integer GetEdgeNumber(const Standard_Integer theEdgeIndex) const + { + return ((theEdgeIndex >= 1 && theEdgeIndex <= 3) ? myEdges[theEdgeIndex - 1] : 0); + } + //! Sets the edge by the index + void SetEdge(const Standard_Integer theEdgeIndex, + const Standard_Integer theEdgeNumber) + { + if (theEdgeIndex >= 1 && theEdgeIndex <= 3) { + myEdges[theEdgeIndex - 1] = theEdgeNumber; + } + } + //! Gets the edges orientation by the index + Standard_Integer GetEdgeOrientation(const Standard_Integer theEdgeIndex) const + { + return ((theEdgeIndex >= 1 && theEdgeIndex <= 3) ? + myEdgesOrientations[theEdgeIndex - 1] : 0); + } + //! Sets the edges orientation by the index + void SetEdgeOrientation(const Standard_Integer theEdgeIndex, + const Standard_Integer theEdgeOrientation) + { + if (theEdgeIndex >= 1 && theEdgeIndex <= 3) { + myEdgesOrientations[theEdgeIndex - 1] = theEdgeOrientation; + } + } + + //! Computes the deflection for the triangle + Standard_EXPORT Standard_Real ComputeDeflection(const Handle(Adaptor3d_HSurface)& theSurface, + const IntPolyh_ArrayOfPoints& thePoints); + + //! Gets the adjacent triangle + Standard_EXPORT Standard_Integer GetNextTriangle(const Standard_Integer theTriangle, + const Standard_Integer theEdgeNum, + const IntPolyh_ArrayOfEdges& TEdges) const; + + //! Splits the triangle on two to decrease its deflection + Standard_EXPORT void MiddleRefinement(const Standard_Integer theTriangleNumber, + const Handle(Adaptor3d_HSurface)& theSurface, + IntPolyh_ArrayOfPoints& TPoints, + IntPolyh_ArrayOfTriangles& TTriangles, + IntPolyh_ArrayOfEdges& TEdges); + + //! Splits the current triangle and new triangles until the refinement + //! criterion is not achieved + Standard_EXPORT void MultipleMiddleRefinement(const Standard_Real theRefineCriterion, + const Bnd_Box& theBox, + const Standard_Integer theTriangleNumber, + const Handle(Adaptor3d_HSurface)& theSurface, + IntPolyh_ArrayOfPoints& TPoints, + IntPolyh_ArrayOfTriangles& TTriangles, + IntPolyh_ArrayOfEdges& TEdges); + + //! Links edges to triangle + Standard_EXPORT void LinkEdges2Triangle(const IntPolyh_ArrayOfEdges& TEdges, + const Standard_Integer theEdge1, + const Standard_Integer theEdge2, + const Standard_Integer theEdge3); + + //! Sets the appropriate edge and orientation for the triangle. + Standard_EXPORT void SetEdgeAndOrientation(const IntPolyh_Edge& theEdge, + const Standard_Integer theEdgeIndex); + + //! Returns the bounding box of the triangle. + Standard_EXPORT const Bnd_Box& BoundingBox(const IntPolyh_ArrayOfPoints& thePoints); + + //! Dumps the contents of the triangle. Standard_EXPORT void Dump (const Standard_Integer v) const; - - Standard_EXPORT void DumpFleche (const Standard_Integer v) const; - - - protected: - - - - private: - - - Standard_Integer p1; - Standard_Integer p2; - Standard_Integer p3; - Standard_Integer e1; - Standard_Integer oe1; - Standard_Integer e2; - Standard_Integer oe2; - Standard_Integer e3; - Standard_Integer oe3; - Standard_Integer II; - Standard_Integer IP; - Standard_Real Fleche; - + Standard_Integer myPoints[3]; + Standard_Integer myEdges[3]; + Standard_Integer myEdgesOrientations[3]; + Standard_Boolean myHasIntersection:1; + Standard_Boolean myIsIntersectionPossible:1; + Standard_Boolean myIsDegenerated:1; + Standard_Real myDeflection; + Bnd_Box myBox; }; - - - - - - #endif // _IntPolyh_Triangle_HeaderFile