From 68b0769935516a289ab3d38d33c5c0e6776d932a Mon Sep 17 00:00:00 2001 From: emv Date: Fri, 7 Apr 2017 07:43:44 +0300 Subject: [PATCH] 0028639: Improve performance of the IntPolyh_MaillageAffinage algorithm The following improvements have been made: 1. Linking edges to triangles while creating the edges. 2. Replacing the array of couples of intersecting triangles with the list to avoid unnecessary allocations of memory. 3. Using the algorithm of unbalanced binary tree when looking for pairs of interfering triangles. 4. Building bounding boxes for the triangles only once and then reusing it. 5. Making the simple methods of the IntPolyh_Point, IntPolyh_Edge, IntPolyh_Triangle, IntPolyh_Couple classes inline. 6. The following methods of the *IntPolyh_Triangle* class have been removed as unused: - *CheckCommonEdge* - *SetEdgeandOrientation* - *MultipleMiddleRefinement2*. 7. The method *IntPolyh_Triangle::TriangleDeflection* has been replaced with the *IntPolyh_Triangle::ComputeDeflection*. 8. The following methods of the *IntPolyh_MaillageAffinage* class have been removed as unused: - *LinkEdges2Triangles*; - *TriangleEdgeContact2*; - *StartingPointsResearch2*; - *NextStartingPointsResearch2*; - *TriangleComparePSP*; - *StartPointsCalcul*. --- dox/dev_guides/upgrade/upgrade.md | 12 + src/IntPolyh/FILES | 6 +- src/IntPolyh/IntPolyh_ArrayOfStartPoints.hxx | 24 - src/IntPolyh/IntPolyh_Couple.cxx | 26 +- src/IntPolyh/IntPolyh_Couple.hxx | 116 +- src/IntPolyh/IntPolyh_CoupleMapHasher.hxx | 46 + src/IntPolyh/IntPolyh_Edge.cxx | 29 +- src/IntPolyh/IntPolyh_Edge.hxx | 112 +- src/IntPolyh/IntPolyh_Intersection.cxx | 136 +- src/IntPolyh/IntPolyh_Intersection.hxx | 4 +- src/IntPolyh/IntPolyh_Intersection_1.cxx | 72 +- ...Couples.hxx => IntPolyh_ListOfCouples.hxx} | 9 +- src/IntPolyh/IntPolyh_MaillageAffinage.cxx | 1910 +++++------------ src/IntPolyh/IntPolyh_MaillageAffinage.hxx | 56 +- src/IntPolyh/IntPolyh_Point.cxx | 245 +-- src/IntPolyh/IntPolyh_Point.hxx | 240 ++- src/IntPolyh/IntPolyh_Triangle.cxx | 793 ++----- src/IntPolyh/IntPolyh_Triangle.hxx | 348 ++- 18 files changed, 1398 insertions(+), 2786 deletions(-) delete mode 100644 src/IntPolyh/IntPolyh_ArrayOfStartPoints.hxx create mode 100644 src/IntPolyh/IntPolyh_CoupleMapHasher.hxx rename src/IntPolyh/{IntPolyh_ArrayOfCouples.hxx => IntPolyh_ListOfCouples.hxx} (73%) 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