OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-08-14 13:30:48 +03:00
Code Activity

Updated source files from path

Browse Source
This commit is contained in:
bugmaster
2018-07-12 16:33:52 +03:00
parent d2c909178e
commit bdab029260
39 changed files with 1229 additions and 1624 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
adm/UDLIST
View File

@@ -105,6 +105,7 @@ n BRepIntCurveSurface
n BRepLib n BRepLib
n BRepMAT2d n BRepMAT2d
n BRepMesh n BRepMesh
n BRepMeshData
n BRepOffset n BRepOffset
n BRepOffsetAPI n BRepOffsetAPI
n BRepPrim n BRepPrim
@@ -141,6 +142,8 @@ n HLRTopoBRep
n HLRAppli n HLRAppli
n Hatch n Hatch
n HatchGen n HatchGen
n IMeshData
n IMeshTools
n IntCurve n IntCurve
n IntCurveSurface n IntCurveSurface
n IntCurvesFace n IntCurvesFace

8
src/AIS/AIS_RubberBand.cxx
View File

@@ -296,13 +296,13 @@ Standard_Boolean AIS_RubberBand::fillTriangles()
Handle(BRepMesh_DataStructureOfDelaun) aMeshStructure = new BRepMesh_DataStructureOfDelaun(anAllocator); Handle(BRepMesh_DataStructureOfDelaun) aMeshStructure = new BRepMesh_DataStructureOfDelaun(anAllocator);
Standard_Integer aPtsLower = myPoints.Lower(); Standard_Integer aPtsLower = myPoints.Lower();
Standard_Integer aPtsUpper = myPoints.Upper(); Standard_Integer aPtsUpper = myPoints.Upper();
BRepMesh::Array1OfInteger anIndexes (0, myPoints.Length() - 1); IMeshData::VectorOfInteger anIndexes (myPoints.Length(), anAllocator);
for (Standard_Integer aPtIdx = aPtsLower; aPtIdx <= aPtsUpper; ++aPtIdx) for (Standard_Integer aPtIdx = aPtsLower; aPtIdx <= aPtsUpper; ++aPtIdx)
{ {
gp_XY aP ((Standard_Real)myPoints.Value (aPtIdx).x(), gp_XY aP ((Standard_Real)myPoints.Value (aPtIdx).x(),
(Standard_Real)myPoints.Value (aPtIdx).y()); (Standard_Real)myPoints.Value (aPtIdx).y());
BRepMesh_Vertex aVertex (aP, aPtIdx, BRepMesh_Frontier); BRepMesh_Vertex aVertex (aP, aPtIdx, BRepMesh_Frontier);
anIndexes.ChangeValue (aPtIdx - aPtsLower) = aMeshStructure->AddNode (aVertex); anIndexes.Append (aMeshStructure->AddNode (aVertex));
} }
Standard_Real aPtSum = 0; Standard_Real aPtSum = 0;
@@ -325,7 +325,7 @@ Standard_Boolean AIS_RubberBand::fillTriangles()
} }
BRepMesh_Delaun aTriangulation (aMeshStructure, anIndexes); BRepMesh_Delaun aTriangulation (aMeshStructure, anIndexes);
const BRepMesh::MapOfInteger& aTriangles = aMeshStructure->ElementsOfDomain(); const IMeshData::MapOfInteger& aTriangles = aMeshStructure->ElementsOfDomain();
if (aTriangles.Extent() < 1) if (aTriangles.Extent() < 1)
return Standard_False; return Standard_False;
@@ -338,7 +338,7 @@ Standard_Boolean AIS_RubberBand::fillTriangles()
} }
Standard_Integer aVertexIndex = 1; Standard_Integer aVertexIndex = 1;
BRepMesh::MapOfInteger::Iterator aTriangleIt (aTriangles); IMeshData::IteratorOfMapOfInteger aTriangleIt (aTriangles);
for (; aTriangleIt.More(); aTriangleIt.Next()) for (; aTriangleIt.More(); aTriangleIt.Next())
{ {
const Standard_Integer aTriangleId = aTriangleIt.Key(); const Standard_Integer aTriangleId = aTriangleIt.Key();

31
src/BRepMesh/BRepMesh_CircleInspector.hxx
View File

@@ -16,7 +16,7 @@
#ifndef BRepMesh_CircleInspector_Header #ifndef BRepMesh_CircleInspector_Header
#define BRepMesh_CircleInspector_Header #define BRepMesh_CircleInspector_Header
#include <BRepMesh.hxx> #include <IMeshData_Types.hxx>
#include <BRepMesh_Circle.hxx> #include <BRepMesh_Circle.hxx>
#include <Precision.hxx> #include <Precision.hxx>
#include <gp_XY.hxx> #include <gp_XY.hxx>
@@ -39,7 +39,7 @@ public:
const Handle(NCollection_IncAllocator)& theAllocator) const Handle(NCollection_IncAllocator)& theAllocator)
: myTolerance(theTolerance*theTolerance), : myTolerance(theTolerance*theTolerance),
myResIndices(theAllocator), myResIndices(theAllocator),
myCircles(theReservedSize) myCircles(theReservedSize, theAllocator)
{ {
} }
@@ -53,7 +53,7 @@ public:
} }
//! Resutns vector of registered circles. //! Resutns vector of registered circles.
inline const BRepMesh::VectorOfCircle& Circles() const inline const IMeshData::VectorOfCircle& Circles() const
{ {
return myCircles; return myCircles;
} }
@@ -75,7 +75,7 @@ public:
} }
//! Returns list of circles shot by the reference point. //! Returns list of circles shot by the reference point.
inline BRepMesh::ListOfInteger& GetShotCircles() inline IMeshData::ListOfInteger& GetShotCircles()
{ {
return myResIndices; return myResIndices;
} }
@@ -83,8 +83,23 @@ public:
//! Performs inspection of a circle with the given index. //! Performs inspection of a circle with the given index.
//! @param theTargetIndex index of a circle to be checked. //! @param theTargetIndex index of a circle to be checked.
//! @return status of the check. //! @return status of the check.
Standard_EXPORT NCollection_CellFilter_Action Inspect( inline NCollection_CellFilter_Action Inspect(
const Standard_Integer theTargetIndex); const Standard_Integer theTargetIndex)
{
BRepMesh_Circle& aCircle = myCircles(theTargetIndex);
const Standard_Real& aRadius = aCircle.Radius();
if (aRadius < 0.)
return CellFilter_Purge;
gp_XY& aLoc = const_cast<gp_XY&>(aCircle.Location());
const Standard_Real aDX = myPoint.ChangeCoord(1) - aLoc.ChangeCoord(1);
const Standard_Real aDY = myPoint.ChangeCoord(2) - aLoc.ChangeCoord(2);
if ((aDX * aDX + aDY * aDY) - (aRadius * aRadius) <= myTolerance)
myResIndices.Append(theTargetIndex);
return CellFilter_Keep;
}
//! Checks indices for equlity. //! Checks indices for equlity.
static Standard_Boolean IsEqual( static Standard_Boolean IsEqual(
@@ -96,8 +111,8 @@ public:
private: private:
Standard_Real myTolerance; Standard_Real myTolerance;
BRepMesh::ListOfInteger myResIndices; IMeshData::ListOfInteger myResIndices;
BRepMesh::VectorOfCircle myCircles; IMeshData::VectorOfCircle myCircles;
gp_XY myPoint; gp_XY myPoint;
}; };

72
src/BRepMesh/BRepMesh_CircleTool.cxx
View File

@@ -21,27 +21,6 @@
#include <BRepMesh_Circle.hxx> #include <BRepMesh_Circle.hxx>
#include <BRepMesh_CircleInspector.hxx> #include <BRepMesh_CircleInspector.hxx>
//=======================================================================
//function : Inspect
//purpose :
//=======================================================================
NCollection_CellFilter_Action BRepMesh_CircleInspector::Inspect(
const Standard_Integer theTargetIndex)
{
const BRepMesh_Circle& aCircle = myCircles(theTargetIndex);
Standard_Real aRadius = aCircle.Radius();
if(aRadius < 0.)
return CellFilter_Purge;
const gp_XY& aLoc = aCircle.Location();
if ((myPoint - aLoc).SquareModulus() - (aRadius * aRadius) <= myTolerance)
myResIndices.Append(theTargetIndex);
return CellFilter_Keep;
}
//======================================================================= //=======================================================================
//function : BRepMesh_CircleTool //function : BRepMesh_CircleTool
//purpose : //purpose :
@@ -117,42 +96,43 @@ Standard_Boolean BRepMesh_CircleTool::MakeCircle(const gp_XY& thePoint1,
static const Standard_Real aPrecision = Precision::PConfusion(); static const Standard_Real aPrecision = Precision::PConfusion();
static const Standard_Real aSqPrecision = aPrecision * aPrecision; static const Standard_Real aSqPrecision = aPrecision * aPrecision;
if ((thePoint1 - thePoint3).SquareModulus() < aSqPrecision) gp_XY aLink1(const_cast<gp_XY&>(thePoint3).ChangeCoord(1) - const_cast<gp_XY&>(thePoint2).ChangeCoord(1),
return Standard_False; const_cast<gp_XY&>(thePoint2).ChangeCoord(2) - const_cast<gp_XY&>(thePoint3).ChangeCoord(2));
gp_XY aLink1(thePoint2 - thePoint1);
if (aLink1.SquareModulus() < aSqPrecision) if (aLink1.SquareModulus() < aSqPrecision)
return Standard_False; return Standard_False;
gp_XY aLink2(thePoint3 - thePoint2); gp_XY aLink2(const_cast<gp_XY&>(thePoint1).ChangeCoord(1) - const_cast<gp_XY&>(thePoint3).ChangeCoord(1),
const_cast<gp_XY&>(thePoint3).ChangeCoord(2) - const_cast<gp_XY&>(thePoint1).ChangeCoord(2));
if (aLink2.SquareModulus() < aSqPrecision) if (aLink2.SquareModulus() < aSqPrecision)
return Standard_False; return Standard_False;
gp_XY aMidPnt1 = (thePoint1 + thePoint2) / 2.; gp_XY aLink3(const_cast<gp_XY&>(thePoint2).ChangeCoord(1) - const_cast<gp_XY&>(thePoint1).ChangeCoord(1),
gp_XY aNorm1 = gp_XY(aLink1.Y(), -aLink1.X()); const_cast<gp_XY&>(thePoint1).ChangeCoord(2) - const_cast<gp_XY&>(thePoint2).ChangeCoord(2));
aNorm1.Add(aMidPnt1); if (aLink3.SquareModulus() < aSqPrecision)
if (aLink2.SquareModulus() < aSqPrecision)
return Standard_False; return Standard_False;
gp_XY aMidPnt2 = (thePoint2 + thePoint3) / 2.; const Standard_Real aD = 2 * (const_cast<gp_XY&>(thePoint1).ChangeCoord(1) * aLink1.Y() +
gp_XY aNorm2 = gp_XY(aLink2.Y(), -aLink2.X()); const_cast<gp_XY&>(thePoint2).ChangeCoord(1) * aLink2.Y() +
aNorm2.Add(aMidPnt2); const_cast<gp_XY&>(thePoint3).ChangeCoord(1) * aLink3.Y());
gp_XY aIntPnt; if (Abs(aD) < gp::Resolution())
Standard_Real aParam[2];
BRepMesh_GeomTool::IntFlag aIntFlag =
BRepMesh_GeomTool::IntLinLin(aMidPnt1, aNorm1,
aMidPnt2, aNorm2, aIntPnt, aParam);
if (aIntFlag != BRepMesh_GeomTool::Cross)
return Standard_False; return Standard_False;
theLocation = aIntPnt; const Standard_Real aInvD = 1. / aD;
const Standard_Real aSqMod1 = thePoint1.SquareModulus();
const Standard_Real aSqMod2 = thePoint2.SquareModulus();
const Standard_Real aSqMod3 = thePoint3.SquareModulus();
theLocation.ChangeCoord(1) = (aSqMod1 * aLink1.Y() +
aSqMod2 * aLink2.Y() +
aSqMod3 * aLink3.Y()) * aInvD;
theRadius = Sqrt(Max(Max((thePoint1 - aIntPnt).SquareModulus(), theLocation.ChangeCoord(2) = (aSqMod1 * aLink1.X() +
(thePoint2 - aIntPnt).SquareModulus()), aSqMod2 * aLink2.X() +
(thePoint3 - aIntPnt).SquareModulus())) + 2 * RealEpsilon(); aSqMod3 * aLink3.X()) * aInvD;
theRadius = Sqrt(Max(Max((thePoint1 - theLocation).SquareModulus(),
(thePoint2 - theLocation).SquareModulus()),
(thePoint3 - theLocation).SquareModulus())) + 2 * RealEpsilon();
return Standard_True; return Standard_True;
} }
@@ -190,7 +170,7 @@ void BRepMesh_CircleTool::Delete(const Standard_Integer theIndex)
//function : Select //function : Select
//purpose : //purpose :
//======================================================================= //=======================================================================
BRepMesh::ListOfInteger& BRepMesh_CircleTool::Select(const gp_XY& thePoint) IMeshData::ListOfInteger& BRepMesh_CircleTool::Select(const gp_XY& thePoint)
{ {
mySelector.SetPoint(thePoint); mySelector.SetPoint(thePoint);
myCellFilter.Inspect(thePoint, mySelector); myCellFilter.Inspect(thePoint, mySelector);

6
src/BRepMesh/BRepMesh_CircleTool.hxx
View File

@@ -24,7 +24,7 @@
#include <gp_XYZ.hxx> #include <gp_XYZ.hxx>
#include <Standard_Integer.hxx> #include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx> #include <Standard_Boolean.hxx>
#include <BRepMesh.hxx> #include <IMeshData_Types.hxx>
#include <NCollection_Array1.hxx> #include <NCollection_Array1.hxx>
class gp_Circ2d; class gp_Circ2d;
@@ -125,7 +125,7 @@ public:
//! Select the circles shot by the given point. //! Select the circles shot by the given point.
//! @param thePoint bullet point. //! @param thePoint bullet point.
Standard_EXPORT BRepMesh::ListOfInteger& Select(const gp_XY& thePoint); Standard_EXPORT IMeshData::ListOfInteger& Select(const gp_XY& thePoint);
private: private:
@@ -141,7 +141,7 @@ private:
Standard_Real myTolerance; Standard_Real myTolerance;
Handle(NCollection_IncAllocator) myAllocator; Handle(NCollection_IncAllocator) myAllocator;
BRepMesh::CircleCellFilter myCellFilter; IMeshData::CircleCellFilter myCellFilter;
BRepMesh_CircleInspector mySelector; BRepMesh_CircleInspector mySelector;
gp_XY myFaceMax; gp_XY myFaceMax;
gp_XY myFaceMin; gp_XY myFaceMin;

74
src/BRepMesh/BRepMesh_Classifier.cxx
View File

@@ -1,7 +1,6 @@
// Created on: 1997-06-26 // Created on: 2016-07-07
// Created by: Laurent PAINNOT // Copyright (c) 2016 OPEN CASCADE SAS
// Copyright (c) 1997-1999 Matra Datavision // Created by: Oleg AGASHIN
// Copyright (c) 1999-2014 OPEN CASCADE SAS
// //
// This file is part of Open CASCADE Technology software library. // This file is part of Open CASCADE Technology software library.
// //
@@ -29,6 +28,14 @@ BRepMesh_Classifier::BRepMesh_Classifier()
{ {
} }
//=======================================================================
//function : Destructor
//purpose :
//=======================================================================
BRepMesh_Classifier::~BRepMesh_Classifier()
{
}
//======================================================================= //=======================================================================
//function : Perform //function : Perform
//purpose : //purpose :
@@ -38,20 +45,24 @@ TopAbs_State BRepMesh_Classifier::Perform(const gp_Pnt2d& thePoint) const
Standard_Boolean isOut = Standard_False; Standard_Boolean isOut = Standard_False;
Standard_Integer aNb = myTabClass.Length(); Standard_Integer aNb = myTabClass.Length();
for (Standard_Integer i = 1; i <= aNb; i++) for (Standard_Integer i = 0; i < aNb; i++)
{ {
Standard_Integer aCur = ((CSLib_Class2d*)myTabClass(i))->SiDans(thePoint); const Standard_Integer aCur = myTabClass(i)->SiDans(thePoint);
if (aCur == 0) if (aCur == 0)
{ {
// Point is ON, but mark it as OUT // Point is ON, but mark it as OUT
isOut = Standard_True; isOut = Standard_True;
} }
else else
{
isOut = myTabOrient(i) ? (aCur == -1) : (aCur == 1); isOut = myTabOrient(i) ? (aCur == -1) : (aCur == 1);
}
if (isOut) if (isOut)
{
return TopAbs_OUT; return TopAbs_OUT;
} }
}
return TopAbs_IN; return TopAbs_IN;
} }
@@ -61,23 +72,23 @@ TopAbs_State BRepMesh_Classifier::Perform(const gp_Pnt2d& thePoint) const
//purpose : //purpose :
//======================================================================= //=======================================================================
void BRepMesh_Classifier::RegisterWire( void BRepMesh_Classifier::RegisterWire(
const NCollection_Sequence<gp_Pnt2d>& theWire, const NCollection_Sequence<const gp_Pnt2d*>& theWire,
const Standard_Real theTolUV, const std::pair<Standard_Real, Standard_Real>& theTolUV,
const Standard_Real theUmin, const std::pair<Standard_Real, Standard_Real>& theRangeU,
const Standard_Real theUmax, const std::pair<Standard_Real, Standard_Real>& theRangeV)
const Standard_Real theVmin,
const Standard_Real theVmax)
{ {
const Standard_Integer aNbPnts = theWire.Length(); const Standard_Integer aNbPnts = theWire.Length();
if (aNbPnts < 2) if (aNbPnts < 2)
{
return; return;
}
// Accumulate angle // Accumulate angle
TColgp_Array1OfPnt2d aPClass(1, aNbPnts); TColgp_Array1OfPnt2d aPClass(1, aNbPnts);
Standard_Real anAngle = 0.0; Standard_Real anAngle = 0.0;
gp_Pnt2d p1 = theWire(1), p2 = theWire(2), p3; const gp_Pnt2d *p1 = theWire(1), *p2 = theWire(2), *p3;
aPClass(1) = p1; aPClass(1) = *p1;
aPClass(2) = p2; aPClass(2) = *p2;
const Standard_Real aAngTol = Precision::Angular(); const Standard_Real aAngTol = Precision::Angular();
const Standard_Real aSqConfusion = const Standard_Real aSqConfusion =
@@ -88,15 +99,15 @@ void BRepMesh_Classifier::RegisterWire(
Standard_Integer ii = i + 2; Standard_Integer ii = i + 2;
if (ii > aNbPnts) if (ii > aNbPnts)
{ {
p3 = aPClass(ii - aNbPnts); p3 = &aPClass(ii - aNbPnts);
} }
else else
{ {
p3 = theWire.Value(ii); p3 = theWire.Value(ii);
aPClass(ii) = p3; aPClass(ii) = *p3;
} }
gp_Vec2d A(p1,p2), B(p2,p3); const gp_Vec2d A(*p1,*p2), B(*p2,*p3);
if (A.SquareMagnitude() > aSqConfusion && if (A.SquareMagnitude() > aSqConfusion &&
B.SquareMagnitude() > aSqConfusion) B.SquareMagnitude() > aSqConfusion)
{ {
@@ -115,27 +126,10 @@ void BRepMesh_Classifier::RegisterWire(
if (Abs(anAngle) < aAngTol) if (Abs(anAngle) < aAngTol)
anAngle = 0.0; anAngle = 0.0;
myTabClass.Append( (void *)new CSLib_Class2d(aPClass, myTabClass.Append(std::shared_ptr<CSLib_Class2d>(new CSLib_Class2d(
theTolUV, theTolUV, theUmin, theVmin, theUmax, theVmax) ); aPClass, theTolUV.first, theTolUV.second,
theRangeU.first, theRangeV.first,
theRangeU.second, theRangeV.second)));
myTabOrient.Append( !(anAngle < 0.0) ); myTabOrient.Append( !(anAngle < 0.0) );
} }
//=======================================================================
//function : Destroy
//purpose :
//=======================================================================
void BRepMesh_Classifier::Destroy()
{
Standard_Integer aNb = myTabClass.Length();
for (Standard_Integer i = 1; i <= aNb; i++)
{
if (myTabClass(i))
{
delete ((CSLib_Class2d*)myTabClass(i));
myTabClass(i) = NULL;
}
}
myTabClass.Clear();
myTabOrient.Clear();
}

51
src/BRepMesh/BRepMesh_Classifier.hxx
View File

@@ -1,7 +1,6 @@
// Created on: 2014-06-03 // Created on: 2016-07-07
// Copyright (c) 2016 OPEN CASCADE SAS
// Created by: Oleg AGASHIN // Created by: Oleg AGASHIN
// Copyright (c) 1997-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
// //
// This file is part of Open CASCADE Technology software library. // This file is part of Open CASCADE Technology software library.
// //
@@ -18,38 +17,30 @@
#define _BRepMesh_Classifier_HeaderFile #define _BRepMesh_Classifier_HeaderFile
#include <Standard.hxx> #include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Macro.hxx> #include <Standard_Macro.hxx>
#include <BRepTopAdaptor_SeqOfPtr.hxx>
#include <TColStd_SequenceOfBoolean.hxx>
#include <TopAbs_State.hxx> #include <TopAbs_State.hxx>
#include <NCollection_Sequence.hxx> #include <IMeshData_Types.hxx>
#include <gp_Pnt2d.hxx>
//! Auxilary class contains information about correctness of discretized #include <memory>
//! face and used for classification of points regarding face internals.
class BRepMesh_Classifier class gp_Pnt2d;
class CSLib_Class2d;
//! Auxilary class intended for classification of points
//! regarding internals of discrete face.
class BRepMesh_Classifier : public Standard_Transient
{ {
public: public:
DEFINE_STANDARD_ALLOC
//! Constructor. //! Constructor.
Standard_EXPORT BRepMesh_Classifier(); Standard_EXPORT BRepMesh_Classifier();
//! Destructor. //! Destructor.
Standard_EXPORT virtual ~BRepMesh_Classifier() Standard_EXPORT virtual ~BRepMesh_Classifier();
{
Destroy();
}
//! Method is called on destruction.
//! Clears internal data structures.
Standard_EXPORT void Destroy();
//! Performs classification of the given point regarding to face internals. //! Performs classification of the given point regarding to face internals.
//! @param thePoint Point in parametric space to be classified. //! @param thePoint Point in parametric space to be classified.
//! @return //! @return TopAbs_IN if point lies within face boundaries and TopAbs_OUT elsewhere.
Standard_EXPORT TopAbs_State Perform(const gp_Pnt2d& thePoint) const; Standard_EXPORT TopAbs_State Perform(const gp_Pnt2d& thePoint) const;
//! Registers wire specified by sequence of points for //! Registers wire specified by sequence of points for
@@ -61,17 +52,17 @@ public:
//! @param theVmin Lower V boundary of the face in parametric space. //! @param theVmin Lower V boundary of the face in parametric space.
//! @param theVmax Upper V boundary of the face in parametric space. //! @param theVmax Upper V boundary of the face in parametric space.
Standard_EXPORT void RegisterWire( Standard_EXPORT void RegisterWire(
const NCollection_Sequence<gp_Pnt2d>& theWire, const NCollection_Sequence<const gp_Pnt2d*>& theWire,
const Standard_Real theTolUV, const std::pair<Standard_Real, Standard_Real>& theTolUV,
const Standard_Real theUmin, const std::pair<Standard_Real, Standard_Real>& theRangeU,
const Standard_Real theUmax, const std::pair<Standard_Real, Standard_Real>& theRangeV);
const Standard_Real theVmin,
const Standard_Real theVmax); DEFINE_STANDARD_RTTI_INLINE (BRepMesh_Classifier, Standard_Transient)
private: private:
BRepTopAdaptor_SeqOfPtr myTabClass; NCollection_Vector<std::shared_ptr<CSLib_Class2d> > myTabClass;
TColStd_SequenceOfBoolean myTabOrient; IMeshData::VectorOfBoolean myTabOrient;
}; };
#endif #endif

85
src/BRepMesh/BRepMesh_DataStructureOfDelaun.cxx
View File

@@ -15,18 +15,15 @@
// commercial license or contractual agreement. // commercial license or contractual agreement.
#include <BRepMesh_DataStructureOfDelaun.hxx> #include <BRepMesh_DataStructureOfDelaun.hxx>
#include <BRepMesh_PairOfIndex.hxx>
#include <BRepBuilderAPI_MakeEdge.hxx> #include <BRepBuilderAPI_MakeEdge.hxx>
#include <BRepBuilderAPI_MakeVertex.hxx> #include <BRepBuilderAPI_MakeVertex.hxx>
#include <BRepMesh_Edge.hxx>
#include <TopoDS_Compound.hxx> #include <TopoDS_Compound.hxx>
#include <BRep_Builder.hxx> #include <BRep_Builder.hxx>
#include <BRepTools.hxx> #include <BRepTools.hxx>
#include <Standard_ErrorHandler.hxx> #include <Standard_ErrorHandler.hxx>
IMPLEMENT_STANDARD_RTTIEXT(BRepMesh_DataStructureOfDelaun,Standard_Transient)
//======================================================================= //=======================================================================
//function : BRepMesh_DataStructureOfDelaun //function : BRepMesh_DataStructureOfDelaun
//purpose : //purpose :
@@ -39,9 +36,7 @@ BRepMesh_DataStructureOfDelaun::BRepMesh_DataStructureOfDelaun(
myNodeLinks (theReservedNodeSize * 3, myAllocator), myNodeLinks (theReservedNodeSize * 3, myAllocator),
myLinks (theReservedNodeSize * 3, myAllocator), myLinks (theReservedNodeSize * 3, myAllocator),
myDelLinks (myAllocator), myDelLinks (myAllocator),
myElements (theReservedNodeSize * 2, myAllocator), myElements (theReservedNodeSize * 2, myAllocator)
myElementsOfDomain(theReservedNodeSize * 2, myAllocator),
myLinksOfDomain (theReservedNodeSize * 2, myAllocator)
{ {
} }
@@ -55,7 +50,7 @@ Standard_Integer BRepMesh_DataStructureOfDelaun::AddNode(
{ {
const Standard_Integer aNodeId = myNodes->Add(theNode, isForceAdd); const Standard_Integer aNodeId = myNodes->Add(theNode, isForceAdd);
if (!myNodeLinks.IsBound(aNodeId)) if (!myNodeLinks.IsBound(aNodeId))
myNodeLinks.Bind(aNodeId, BRepMesh::ListOfInteger(myAllocator)); myNodeLinks.Bind(aNodeId, IMeshData::ListOfInteger(myAllocator));
return aNodeId; return aNodeId;
} }
@@ -174,8 +169,8 @@ void BRepMesh_DataStructureOfDelaun::cleanLink(
const Standard_Integer aNodeId = (i == 0) ? const Standard_Integer aNodeId = (i == 0) ?
theLink.FirstNode() : theLink.LastNode(); theLink.FirstNode() : theLink.LastNode();
BRepMesh::ListOfInteger& aLinkList = linksConnectedTo(aNodeId); IMeshData::ListOfInteger& aLinkList = linksConnectedTo(aNodeId);
BRepMesh::ListOfInteger::Iterator aLinkIt(aLinkList); IMeshData::ListOfInteger::Iterator aLinkIt(aLinkList);
for(; aLinkIt.More(); aLinkIt.Next()) for(; aLinkIt.More(); aLinkIt.Next())
{ {
if (aLinkIt.Value() == theIndex) if (aLinkIt.Value() == theIndex)
@@ -194,16 +189,11 @@ void BRepMesh_DataStructureOfDelaun::cleanLink(
Standard_Integer BRepMesh_DataStructureOfDelaun::AddElement( Standard_Integer BRepMesh_DataStructureOfDelaun::AddElement(
const BRepMesh_Triangle& theElement) const BRepMesh_Triangle& theElement)
{ {
Standard_Integer aElementIndex = IndexOf(theElement); myElements.Append(theElement);
if (aElementIndex > 0) Standard_Integer aElementIndex = myElements.Size();
return aElementIndex;
aElementIndex = myElements.Add(theElement);
myElementsOfDomain.Add(aElementIndex); myElementsOfDomain.Add(aElementIndex);
Standard_Integer e[3]; const Standard_Integer (&e)[3] = theElement.myEdges;
Standard_Boolean o[3];
theElement.Edges(e, o);
for (Standard_Integer i = 0; i < 3; ++i) for (Standard_Integer i = 0; i < 3; ++i)
myLinks(e[i]).Append(aElementIndex); myLinks(e[i]).Append(aElementIndex);
@@ -237,10 +227,7 @@ void BRepMesh_DataStructureOfDelaun::cleanElement(
if (theElement.Movability() != BRepMesh_Free) if (theElement.Movability() != BRepMesh_Free)
return; return;
Standard_Integer e[3]; const Standard_Integer(&e)[3] = theElement.myEdges;
Standard_Boolean o[3];
theElement.Edges(e, o);
for (Standard_Integer i = 0; i < 3; ++i) for (Standard_Integer i = 0; i < 3; ++i)
removeElementIndex(theIndex, myLinks(e[i])); removeElementIndex(theIndex, myLinks(e[i]));
} }
@@ -274,20 +261,15 @@ Standard_Boolean BRepMesh_DataStructureOfDelaun::SubstituteElement(
const BRepMesh_Triangle& aElement = GetElement(theIndex); const BRepMesh_Triangle& aElement = GetElement(theIndex);
if (aElement.Movability() == BRepMesh_Deleted) if (aElement.Movability() == BRepMesh_Deleted)
{ {
myElements.Substitute(theIndex, theNewElement); myElements(theIndex) = theNewElement;
return Standard_True; return Standard_True;
} }
if (IndexOf(theNewElement) != 0)
return Standard_False;
cleanElement(theIndex, aElement); cleanElement(theIndex, aElement);
// Warning: here new element and old element should have different Hash code // Warning: here new element and old element should have different Hash code
myElements.Substitute(theIndex, theNewElement); myElements(theIndex) = theNewElement;
Standard_Integer e[3]; const Standard_Integer(&e)[3] = theNewElement.myEdges;
Standard_Boolean o[3];
theNewElement.Edges(e, o);
for (Standard_Integer i = 0; i < 3; ++i) for (Standard_Integer i = 0; i < 3; ++i)
myLinks(e[i]).Append(theIndex); myLinks(e[i]).Append(theIndex);
@@ -302,9 +284,8 @@ void BRepMesh_DataStructureOfDelaun::ElementNodes(
const BRepMesh_Triangle& theElement, const BRepMesh_Triangle& theElement,
Standard_Integer (&theNodes)[3]) Standard_Integer (&theNodes)[3])
{ {
Standard_Integer e[3]; const Standard_Integer(&e)[3] = theElement.myEdges;
Standard_Boolean o[3]; const Standard_Boolean(&o)[3] = theElement.myOrientations;
theElement.Edges(e, o);
const BRepMesh_Edge& aLink1 = GetLink(e[0]); const BRepMesh_Edge& aLink1 = GetLink(e[0]);
if (o[0]) if (o[0])
@@ -331,16 +312,14 @@ void BRepMesh_DataStructureOfDelaun::ElementNodes(
//======================================================================= //=======================================================================
void BRepMesh_DataStructureOfDelaun::ClearDomain() void BRepMesh_DataStructureOfDelaun::ClearDomain()
{ {
BRepMesh::MapOfInteger aFreeEdges; IMeshData::MapOfInteger aFreeEdges;
BRepMesh::MapOfInteger::Iterator aElementIt(myElementsOfDomain); IMeshData::IteratorOfMapOfInteger aElementIt(myElementsOfDomain);
for (; aElementIt.More(); aElementIt.Next()) for (; aElementIt.More(); aElementIt.Next())
{ {
const Standard_Integer aElementId = aElementIt.Key(); const Standard_Integer aElementId = aElementIt.Key();
BRepMesh_Triangle& aElement = (BRepMesh_Triangle&)GetElement(aElementId); BRepMesh_Triangle& aElement = (BRepMesh_Triangle&)GetElement(aElementId);
Standard_Integer e[3]; const Standard_Integer(&e)[3] = aElement.myEdges;
Standard_Boolean o[3];
aElement.Edges(e, o);
for (Standard_Integer i = 0; i < 3; ++i) for (Standard_Integer i = 0; i < 3; ++i)
aFreeEdges.Add(e[i]); aFreeEdges.Add(e[i]);
@@ -350,7 +329,7 @@ void BRepMesh_DataStructureOfDelaun::ClearDomain()
} }
myElementsOfDomain.Clear(); myElementsOfDomain.Clear();
BRepMesh::MapOfInteger::Iterator aEdgeIt(aFreeEdges); IMeshData::IteratorOfMapOfInteger aEdgeIt(aFreeEdges);
for (; aEdgeIt.More(); aEdgeIt.Next()) for (; aEdgeIt.More(); aEdgeIt.Next())
RemoveLink(aEdgeIt.Key()); RemoveLink(aEdgeIt.Key());
} }
@@ -390,7 +369,7 @@ void BRepMesh_DataStructureOfDelaun::clearDeletedLinks()
--aLastLiveItem; --aLastLiveItem;
const Standard_Integer aLastLiveItemId = aLastLiveItem + 1; const Standard_Integer aLastLiveItemId = aLastLiveItem + 1;
BRepMesh::ListOfInteger::Iterator aLinkIt; IMeshData::ListOfInteger::Iterator aLinkIt;
// update link references // update link references
for (Standard_Integer i = 0; i < 2; ++i) for (Standard_Integer i = 0; i < 2; ++i)
{ {
@@ -411,10 +390,9 @@ void BRepMesh_DataStructureOfDelaun::clearDeletedLinks()
// update elements references // update elements references
for(Standard_Integer j = 1, jn = aPair.Extent(); j <= jn; ++j) for(Standard_Integer j = 1, jn = aPair.Extent(); j <= jn; ++j)
{ {
const BRepMesh_Triangle& aElement = GetElement(aPair.Index(j));
Standard_Integer e[3]; Standard_Integer e[3];
Standard_Boolean o[3]; Standard_Boolean o[3];
const BRepMesh_Triangle& aElement = GetElement(aPair.Index(j));
aElement.Edges(e, o); aElement.Edges(e, o);
for (Standard_Integer i = 0; i < 3; ++i) for (Standard_Integer i = 0; i < 3; ++i)
{ {
@@ -425,8 +403,7 @@ void BRepMesh_DataStructureOfDelaun::clearDeletedLinks()
} }
} }
myElements.Substitute(aLinkIt.Value(), myElements(aLinkIt.Value()) = BRepMesh_Triangle(e, o, aElement.Movability());
BRepMesh_Triangle(e, o, aElement.Movability()));
} }
} }
} }
@@ -437,8 +414,8 @@ void BRepMesh_DataStructureOfDelaun::clearDeletedLinks()
//======================================================================= //=======================================================================
void BRepMesh_DataStructureOfDelaun::clearDeletedNodes() void BRepMesh_DataStructureOfDelaun::clearDeletedNodes()
{ {
BRepMesh::ListOfInteger& aDelNodes = IMeshData::ListOfInteger& aDelNodes =
(BRepMesh::ListOfInteger&)myNodes->GetListOfDelNodes(); (IMeshData::ListOfInteger&)myNodes->GetListOfDelNodes();
Standard_Integer aLastLiveItem = NbNodes(); Standard_Integer aLastLiveItem = NbNodes();
while (!aDelNodes.IsEmpty()) while (!aDelNodes.IsEmpty())
@@ -459,7 +436,7 @@ void BRepMesh_DataStructureOfDelaun::clearDeletedNodes()
continue; continue;
BRepMesh_Vertex aNode = GetNode(aLastLiveItem); BRepMesh_Vertex aNode = GetNode(aLastLiveItem);
BRepMesh::ListOfInteger& aLinkList = linksConnectedTo(aLastLiveItem); IMeshData::ListOfInteger& aLinkList = linksConnectedTo(aLastLiveItem);
myNodes->RemoveLast(); myNodes->RemoveLast();
--aLastLiveItem; --aLastLiveItem;
@@ -468,7 +445,7 @@ void BRepMesh_DataStructureOfDelaun::clearDeletedNodes()
myNodeLinks.ChangeFind(aDelItem) = aLinkList; myNodeLinks.ChangeFind(aDelItem) = aLinkList;
const Standard_Integer aLastLiveItemId = aLastLiveItem + 1; const Standard_Integer aLastLiveItemId = aLastLiveItem + 1;
BRepMesh::ListOfInteger::Iterator aLinkIt(aLinkList); IMeshData::ListOfInteger::Iterator aLinkIt(aLinkList);
for (; aLinkIt.More(); aLinkIt.Next()) for (; aLinkIt.More(); aLinkIt.Next())
{ {
const Standard_Integer aLinkId = aLinkIt.Value(); const Standard_Integer aLinkId = aLinkIt.Value();
@@ -502,7 +479,7 @@ void BRepMesh_DataStructureOfDelaun::Statistics(Standard_OStream& theStream) con
theStream << "\n Deleted links : " << myDelLinks.Extent() << endl; theStream << "\n Deleted links : " << myDelLinks.Extent() << endl;
theStream << "\n\n Map of elements : \n"; theStream << "\n\n Map of elements : \n";
myElements.Statistics(theStream); theStream << "\n Elements : " << myElements.Size() << endl;
} }
//======================================================================= //=======================================================================
@@ -547,10 +524,10 @@ Standard_CString BRepMesh_Dump(void* theMeshHandlePtr,
} }
else else
{ {
BRepMesh::MapOfInteger::Iterator aLinksIt(aMeshData->LinksOfDomain()); IMeshData::IteratorOfMapOfInteger aLinksIt(aMeshData->LinksOfDomain());
for (; aLinksIt.More(); aLinksIt.Next()) for (; aLinksIt.More(); aLinksIt.Next())
{ {
const BRepMesh_Edge& aLink = aMeshData->GetLink(aLinksIt.Value()); const BRepMesh_Edge& aLink = aMeshData->GetLink(aLinksIt.Key());
gp_Pnt aPnt[2]; gp_Pnt aPnt[2];
for (Standard_Integer i = 0; i < 2; ++i) for (Standard_Integer i = 0; i < 2; ++i)
{ {
@@ -578,3 +555,9 @@ Standard_CString BRepMesh_Dump(void* theMeshHandlePtr,
return theFileNameStr; return theFileNameStr;
} }
void BRepMesh_DataStructureOfDelaun::Dump(Standard_CString theFileNameStr)
{
Handle(BRepMesh_DataStructureOfDelaun) aMeshData (this);
BRepMesh_Dump((void*)&aMeshData, theFileNameStr);
}

51
src/BRepMesh/BRepMesh_DataStructureOfDelaun.hxx
View File

@@ -14,17 +14,14 @@
#ifndef _BRepMesh_DataStructureOfDelaun_HeaderFile #ifndef _BRepMesh_DataStructureOfDelaun_HeaderFile
#define _BRepMesh_DataStructureOfDelaun_HeaderFile #define _BRepMesh_DataStructureOfDelaun_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <BRepMesh_VertexTool.hxx>
#include <Standard_Transient.hxx> #include <Standard_Transient.hxx>
#include <BRepMesh_Triangle.hxx> #include <BRepMesh_Triangle.hxx>
#include <BRepMesh_PairOfIndex.hxx> #include <BRepMesh_PairOfIndex.hxx>
#include <Standard_OStream.hxx> #include <Standard_OStream.hxx>
#include <BRepMesh.hxx> #include <IMeshData_Types.hxx>
#include <BRepMesh_VertexTool.hxx>
class BRepMesh_Vertex; class BRepMesh_Vertex;
class BRepMesh_VertexTool;
class BRepMesh_Edge; class BRepMesh_Edge;
//! Describes the data structure necessary for the mesh algorithms in //! Describes the data structure necessary for the mesh algorithms in
@@ -108,7 +105,7 @@ public: //! @name API for accessing mesh nodes.
//! Get list of links attached to the node with the given index. //! Get list of links attached to the node with the given index.
//! @param theIndex index of node whose links should be retrieved. //! @param theIndex index of node whose links should be retrieved.
//! @return list of links attached to the node. //! @return list of links attached to the node.
inline const BRepMesh::ListOfInteger& LinksConnectedTo( inline const IMeshData::ListOfInteger& LinksConnectedTo(
const Standard_Integer theIndex) const const Standard_Integer theIndex) const
{ {
return linksConnectedTo(theIndex); return linksConnectedTo(theIndex);
@@ -145,7 +142,7 @@ public: //! @name API for accessing mesh links.
} }
//! Returns map of indices of links registered in mesh. //! Returns map of indices of links registered in mesh.
inline const BRepMesh::MapOfInteger& LinksOfDomain() const inline const IMeshData::MapOfInteger& LinksOfDomain() const
{ {
return myLinksOfDomain; return myLinksOfDomain;
} }
@@ -181,7 +178,7 @@ public: //! @name API for accessing mesh elements.
//! Returns number of links. //! Returns number of links.
inline Standard_Integer NbElements() const inline Standard_Integer NbElements() const
{ {
return myElements.Extent(); return myElements.Size();
} }
//! Adds element to the mesh if it is not already in the mesh. //! Adds element to the mesh if it is not already in the mesh.
@@ -189,24 +186,16 @@ public: //! @name API for accessing mesh elements.
//! @return index of the element in the structure. //! @return index of the element in the structure.
Standard_EXPORT Standard_Integer AddElement(const BRepMesh_Triangle& theElement); Standard_EXPORT Standard_Integer AddElement(const BRepMesh_Triangle& theElement);
//! Finds the index of the given element.
//! @param theElement element to find.
//! @return index of the given element of zero if element is not in the mesh.
Standard_Integer IndexOf(const BRepMesh_Triangle& theElement) const
{
return myElements.FindIndex(theElement);
}
//! Get element by the index. //! Get element by the index.
//! @param theIndex index of an element. //! @param theIndex index of an element.
//! @return element with the given index. //! @return element with the given index.
const BRepMesh_Triangle& GetElement(const Standard_Integer theIndex) const BRepMesh_Triangle& GetElement(const Standard_Integer theIndex)
{ {
return myElements.FindKey(theIndex); return myElements.ChangeValue(theIndex - 1);
} }
//! Returns map of indices of elements registered in mesh. //! Returns map of indices of elements registered in mesh.
inline const BRepMesh::MapOfInteger& ElementsOfDomain() const inline const IMeshData::MapOfInteger& ElementsOfDomain() const
{ {
return myElementsOfDomain; return myElementsOfDomain;
} }
@@ -229,6 +218,8 @@ public: //! @name API for accessing mesh elements.
const BRepMesh_Triangle& theElement, const BRepMesh_Triangle& theElement,
Standard_Integer (&theNodes)[3]); Standard_Integer (&theNodes)[3]);
Standard_EXPORT void Dump(Standard_CString theFileNameStr);
public: //! @name Auxilary API public: //! @name Auxilary API
@@ -244,7 +235,7 @@ public: //! @name Auxilary API
} }
//! Gives the data structure for initialization of cell size and tolerance. //! Gives the data structure for initialization of cell size and tolerance.
inline BRepMesh::HVertexTool& Data() inline const Handle(BRepMesh_VertexTool)& Data()
{ {
return myNodes; return myNodes;
} }
@@ -260,17 +251,17 @@ public: //! @name Auxilary API
clearDeletedNodes(); clearDeletedNodes();
} }
DEFINE_STANDARD_RTTIEXT(BRepMesh_DataStructureOfDelaun,Standard_Transient) DEFINE_STANDARD_RTTI_INLINE(BRepMesh_DataStructureOfDelaun, Standard_Transient)
private: private:
//! Get list of links attached to the node with the given index. //! Get list of links attached to the node with the given index.
//! @param theIndex index of node whose links should be retrieved. //! @param theIndex index of node whose links should be retrieved.
//! @return list of links attached to the node. //! @return list of links attached to the node.
inline BRepMesh::ListOfInteger& linksConnectedTo( inline IMeshData::ListOfInteger& linksConnectedTo(
const Standard_Integer theIndex) const const Standard_Integer theIndex) const
{ {
return (BRepMesh::ListOfInteger&)myNodeLinks.Find(theIndex); return (IMeshData::ListOfInteger&)myNodeLinks.Find(theIndex);
} }
//! Substitutes deleted links by the last one from corresponding map //! Substitutes deleted links by the last one from corresponding map
@@ -305,15 +296,13 @@ private:
private: private:
Handle(NCollection_IncAllocator) myAllocator; Handle(NCollection_IncAllocator) myAllocator;
BRepMesh::HVertexTool myNodes; Handle(BRepMesh_VertexTool) myNodes;
BRepMesh::DMapOfIntegerListOfInteger myNodeLinks; IMeshData::DMapOfIntegerListOfInteger myNodeLinks;
BRepMesh::IDMapOfLink myLinks; IMeshData::IDMapOfLink myLinks;
BRepMesh::ListOfInteger myDelLinks; IMeshData::ListOfInteger myDelLinks;
BRepMesh::IMapOfElement myElements; IMeshData::VectorOfElements myElements;
BRepMesh::MapOfInteger myElementsOfDomain; IMeshData::MapOfInteger myElementsOfDomain;
BRepMesh::MapOfInteger myLinksOfDomain; IMeshData::MapOfInteger myLinksOfDomain;
}; };
DEFINE_STANDARD_HANDLE(BRepMesh_DataStructureOfDelaun,Standard_Transient)
#endif #endif

310
src/BRepMesh/BRepMesh_Delaun.cxx
View File

@@ -82,14 +82,14 @@ namespace {
//function : BRepMesh_Delaun //function : BRepMesh_Delaun
//purpose : Creates the triangulation with an empty Mesh data structure //purpose : Creates the triangulation with an empty Mesh data structure
//======================================================================= //=======================================================================
BRepMesh_Delaun::BRepMesh_Delaun(BRepMesh::Array1OfVertexOfDelaun& theVertices) BRepMesh_Delaun::BRepMesh_Delaun(IMeshData::Array1OfVertexOfDelaun& theVertices)
: myCircles (theVertices.Length(), new NCollection_IncAllocator( : myCircles (theVertices.Length(), new NCollection_IncAllocator(
BRepMesh::MEMORY_BLOCK_SIZE_HUGE)) IMeshData::MEMORY_BLOCK_SIZE_HUGE))
{ {
if ( theVertices.Length() > 2 ) if ( theVertices.Length() > 2 )
{ {
myMeshData = new BRepMesh_DataStructureOfDelaun( myMeshData = new BRepMesh_DataStructureOfDelaun(
new NCollection_IncAllocator(BRepMesh::MEMORY_BLOCK_SIZE_HUGE), new NCollection_IncAllocator(IMeshData::MEMORY_BLOCK_SIZE_HUGE),
theVertices.Length() ); theVertices.Length() );
Init( theVertices ); Init( theVertices );
} }
@@ -100,8 +100,8 @@ BRepMesh_Delaun::BRepMesh_Delaun(BRepMesh::Array1OfVertexOfDelaun& theVertices)
//purpose : Creates the triangulation with and existent Mesh data structure //purpose : Creates the triangulation with and existent Mesh data structure
//======================================================================= //=======================================================================
BRepMesh_Delaun::BRepMesh_Delaun( BRepMesh_Delaun::BRepMesh_Delaun(
const Handle( BRepMesh_DataStructureOfDelaun )& theOldMesh, const Handle(BRepMesh_DataStructureOfDelaun)& theOldMesh,
BRepMesh::Array1OfVertexOfDelaun& theVertices) IMeshData::Array1OfVertexOfDelaun& theVertices)
: myMeshData( theOldMesh ), : myMeshData( theOldMesh ),
myCircles ( theVertices.Length(), theOldMesh->Allocator() ) myCircles ( theVertices.Length(), theOldMesh->Allocator() )
{ {
@@ -114,8 +114,8 @@ BRepMesh_Delaun::BRepMesh_Delaun(
//purpose : Creates the triangulation with and existent Mesh data structure //purpose : Creates the triangulation with and existent Mesh data structure
//======================================================================= //=======================================================================
BRepMesh_Delaun::BRepMesh_Delaun( BRepMesh_Delaun::BRepMesh_Delaun(
const Handle( BRepMesh_DataStructureOfDelaun )& theOldMesh, const Handle(BRepMesh_DataStructureOfDelaun)& theOldMesh,
BRepMesh::Array1OfInteger& theVertexIndices) IMeshData::VectorOfInteger& theVertexIndices)
: myMeshData( theOldMesh ), : myMeshData( theOldMesh ),
myCircles ( theVertexIndices.Length(), theOldMesh->Allocator() ) myCircles ( theVertexIndices.Length(), theOldMesh->Allocator() )
{ {
@@ -135,18 +135,18 @@ BRepMesh_Delaun::BRepMesh_Delaun(
//function : Init //function : Init
//purpose : Initializes the triangulation with an Array of Vertex //purpose : Initializes the triangulation with an Array of Vertex
//======================================================================= //=======================================================================
void BRepMesh_Delaun::Init(BRepMesh::Array1OfVertexOfDelaun& theVertices) void BRepMesh_Delaun::Init(IMeshData::Array1OfVertexOfDelaun& theVertices)
{ {
Bnd_Box2d aBox; Bnd_Box2d aBox;
Standard_Integer aLowerIdx = theVertices.Lower(); Standard_Integer aLowerIdx = theVertices.Lower();
Standard_Integer anUpperIdx = theVertices.Upper(); Standard_Integer anUpperIdx = theVertices.Upper();
BRepMesh::Array1OfInteger aVertexIndexes( aLowerIdx, anUpperIdx ); IMeshData::VectorOfInteger aVertexIndexes(theVertices.Size());
Standard_Integer anIndex = aLowerIdx; Standard_Integer anIndex = aLowerIdx;
for ( ; anIndex <= anUpperIdx; ++anIndex ) for ( ; anIndex <= anUpperIdx; ++anIndex )
{ {
aBox.Add( gp_Pnt2d( theVertices( anIndex ).Coord() ) ); aBox.Add( gp_Pnt2d( theVertices( anIndex ).Coord() ) );
aVertexIndexes( anIndex ) = myMeshData->AddNode( theVertices( anIndex ) ); aVertexIndexes.Append(myMeshData->AddNode( theVertices( anIndex ) ));
} }
perform( aBox, aVertexIndexes ); perform( aBox, aVertexIndexes );
@@ -157,7 +157,7 @@ void BRepMesh_Delaun::Init(BRepMesh::Array1OfVertexOfDelaun& theVertices)
//purpose : Create super mesh and run triangulation procedure //purpose : Create super mesh and run triangulation procedure
//======================================================================= //=======================================================================
void BRepMesh_Delaun::perform(Bnd_Box2d& theBndBox, void BRepMesh_Delaun::perform(Bnd_Box2d& theBndBox,
BRepMesh::Array1OfInteger& theVertexIndexes) IMeshData::VectorOfInteger& theVertexIndexes)
{ {
theBndBox.Enlarge( Precision ); theBndBox.Enlarge( Precision );
superMesh( theBndBox ); superMesh( theBndBox );
@@ -227,13 +227,13 @@ void BRepMesh_Delaun::superMesh( const Bnd_Box2d& theBox )
// When an edge is suppressed more than one time it is destroyed. // When an edge is suppressed more than one time it is destroyed.
//======================================================================= //=======================================================================
void BRepMesh_Delaun::deleteTriangle(const Standard_Integer theIndex, void BRepMesh_Delaun::deleteTriangle(const Standard_Integer theIndex,
BRepMesh::MapOfIntegerInteger& theLoopEdges ) IMeshData::MapOfIntegerInteger& theLoopEdges )
{ {
myCircles.Delete( theIndex ); myCircles.Delete( theIndex );
Standard_Integer e[3]; const BRepMesh_Triangle& aElement = GetTriangle(theIndex);
Standard_Boolean o[3]; const Standard_Integer(&e)[3] = aElement.myEdges;
GetTriangle( theIndex ).Edges( e, o ); const Standard_Boolean(&o)[3] = aElement.myOrientations;
myMeshData->RemoveElement( theIndex ); myMeshData->RemoveElement( theIndex );
@@ -252,13 +252,11 @@ void BRepMesh_Delaun::deleteTriangle(const Standard_Integer theIndex,
//purpose : Computes the triangulation and add the vertices edges and //purpose : Computes the triangulation and add the vertices edges and
// triangles to the Mesh data structure // triangles to the Mesh data structure
//======================================================================= //=======================================================================
void BRepMesh_Delaun::compute(BRepMesh::Array1OfInteger& theVertexIndexes) void BRepMesh_Delaun::compute(IMeshData::VectorOfInteger& theVertexIndexes)
{ {
// Insertion of edges of super triangles in the list of free edges: // Insertion of edges of super triangles in the list of free edges:
BRepMesh::MapOfIntegerInteger aLoopEdges(10, myMeshData->Allocator()); IMeshData::MapOfIntegerInteger aLoopEdges(10, myMeshData->Allocator());
Standard_Integer e[3]; const Standard_Integer(&e)[3] = mySupTrian.myEdges;
Standard_Boolean o[3];
mySupTrian.Edges( e, o );
aLoopEdges.Bind( e[0], Standard_True ); aLoopEdges.Bind( e[0], Standard_True );
aLoopEdges.Bind( e[1], Standard_True ); aLoopEdges.Bind( e[1], Standard_True );
@@ -280,13 +278,13 @@ void BRepMesh_Delaun::compute(BRepMesh::Array1OfInteger& theVertexIndexes)
aSelector.NeighboursOfNode( mySupVert[aSupVertId] ); aSelector.NeighboursOfNode( mySupVert[aSupVertId] );
aLoopEdges.Clear(); aLoopEdges.Clear();
BRepMesh::MapOfInteger::Iterator aFreeTriangles( aSelector.Elements() ); IMeshData::IteratorOfMapOfInteger aFreeTriangles( aSelector.Elements() );
for ( ; aFreeTriangles.More(); aFreeTriangles.Next() ) for ( ; aFreeTriangles.More(); aFreeTriangles.Next() )
deleteTriangle( aFreeTriangles.Key(), aLoopEdges ); deleteTriangle( aFreeTriangles.Key(), aLoopEdges );
// All edges that remain free are removed from aLoopEdges; // All edges that remain free are removed from aLoopEdges;
// only the boundary edges of the triangulation remain there // only the boundary edges of the triangulation remain there
BRepMesh::MapOfIntegerInteger::Iterator aFreeEdges( aLoopEdges ); IMeshData::MapOfIntegerInteger::Iterator aFreeEdges( aLoopEdges );
for ( ; aFreeEdges.More(); aFreeEdges.Next() ) for ( ; aFreeEdges.More(); aFreeEdges.Next() )
{ {
if ( myMeshData->ElementsConnectedTo( aFreeEdges.Key() ).IsEmpty() ) if ( myMeshData->ElementsConnectedTo( aFreeEdges.Key() ).IsEmpty() )
@@ -303,18 +301,18 @@ void BRepMesh_Delaun::compute(BRepMesh::Array1OfInteger& theVertexIndexes)
//purpose : Creates the triangles beetween the node and the polyline. //purpose : Creates the triangles beetween the node and the polyline.
//======================================================================= //=======================================================================
void BRepMesh_Delaun::createTriangles(const Standard_Integer theVertexIndex, void BRepMesh_Delaun::createTriangles(const Standard_Integer theVertexIndex,
BRepMesh::MapOfIntegerInteger& thePoly) IMeshData::MapOfIntegerInteger& thePoly)
{ {
BRepMesh::ListOfInteger aLoopEdges, anExternalEdges; IMeshData::ListOfInteger aLoopEdges, anExternalEdges;
const gp_XY& aVertexCoord = myMeshData->GetNode( theVertexIndex ).Coord(); const gp_XY& aVertexCoord = myMeshData->GetNode( theVertexIndex ).Coord();
BRepMesh::MapOfIntegerInteger::Iterator anEdges( thePoly ); IMeshData::MapOfIntegerInteger::Iterator anEdges( thePoly );
for ( ; anEdges.More(); anEdges.Next() ) for ( ; anEdges.More(); anEdges.Next() )
{ {
Standard_Integer anEdgeId = anEdges.Key(); Standard_Integer anEdgeId = anEdges.Key();
const BRepMesh_Edge& anEdge = GetEdge( anEdgeId ); const BRepMesh_Edge& anEdge = GetEdge( anEdgeId );
const Standard_Boolean isPositive = thePoly (anEdgeId) != 0; Standard_Boolean isPositive = thePoly( anEdgeId ) != 0;
Standard_Integer aNodes[3]; Standard_Integer aNodes[3];
if ( isPositive ) if ( isPositive )
@@ -424,10 +422,10 @@ void BRepMesh_Delaun::createTriangles(const Standard_Integer theVertexIn
//purpose : Creation of triangles from the new nodes //purpose : Creation of triangles from the new nodes
//======================================================================= //=======================================================================
void BRepMesh_Delaun::createTrianglesOnNewVertices( void BRepMesh_Delaun::createTrianglesOnNewVertices(
BRepMesh::Array1OfInteger& theVertexIndexes) IMeshData::VectorOfInteger& theVertexIndexes)
{ {
Handle(NCollection_IncAllocator) aAllocator = Handle(NCollection_IncAllocator) aAllocator =
new NCollection_IncAllocator(BRepMesh::MEMORY_BLOCK_SIZE_HUGE); new NCollection_IncAllocator(IMeshData::MEMORY_BLOCK_SIZE_HUGE);
Standard_Real aTolU, aTolV; Standard_Real aTolU, aTolV;
myMeshData->Data()->GetTolerance(aTolU, aTolV); myMeshData->Data()->GetTolerance(aTolU, aTolV);
@@ -441,16 +439,16 @@ void BRepMesh_Delaun::createTrianglesOnNewVertices(
for( ; anIndex <= anUpper; ++anIndex ) for( ; anIndex <= anUpper; ++anIndex )
{ {
aAllocator->Reset(Standard_False); aAllocator->Reset(Standard_False);
BRepMesh::MapOfIntegerInteger aLoopEdges(10, aAllocator); IMeshData::MapOfIntegerInteger aLoopEdges(10, aAllocator);
Standard_Integer aVertexIdx = theVertexIndexes( anIndex ); Standard_Integer aVertexIdx = theVertexIndexes( anIndex );
const BRepMesh_Vertex& aVertex = GetVertex( aVertexIdx ); const BRepMesh_Vertex& aVertex = GetVertex( aVertexIdx );
// Iterator in the list of indexes of circles containing the node // Iterator in the list of indexes of circles containing the node
BRepMesh::ListOfInteger& aCirclesList = myCircles.Select( aVertex.Coord() ); IMeshData::ListOfInteger& aCirclesList = myCircles.Select( aVertex.Coord() );
Standard_Integer onEgdeId = 0, aTriangleId = 0; Standard_Integer onEgdeId = 0, aTriangleId = 0;
BRepMesh::ListOfInteger::Iterator aCircleIt( aCirclesList ); IMeshData::ListOfInteger::Iterator aCircleIt( aCirclesList );
for ( ; aCircleIt.More(); aCircleIt.Next() ) for ( ; aCircleIt.More(); aCircleIt.Next() )
{ {
// To add a node in the mesh it is necessary to check conditions: // To add a node in the mesh it is necessary to check conditions:
@@ -484,12 +482,11 @@ void BRepMesh_Delaun::createTrianglesOnNewVertices(
while ( isModify && !aCirclesList.IsEmpty() ) while ( isModify && !aCirclesList.IsEmpty() )
{ {
isModify = Standard_False; isModify = Standard_False;
BRepMesh::ListOfInteger::Iterator aCircleIt1( aCirclesList ); IMeshData::ListOfInteger::Iterator aCircleIt1( aCirclesList );
for ( ; aCircleIt1.More(); aCircleIt1.Next() ) for ( ; aCircleIt1.More(); aCircleIt1.Next() )
{ {
Standard_Integer e[3]; const BRepMesh_Triangle& aElement = GetTriangle(aCircleIt1.Value());
Standard_Boolean o[3]; const Standard_Integer(&e)[3] = aElement.myEdges;
GetTriangle( aCircleIt1.Value() ).Edges( e, o );
if ( aLoopEdges.IsBound( e[0] ) || if ( aLoopEdges.IsBound( e[0] ) ||
aLoopEdges.IsBound( e[1] ) || aLoopEdges.IsBound( e[1] ) ||
@@ -521,13 +518,11 @@ void BRepMesh_Delaun::createTrianglesOnNewVertices(
//======================================================================= //=======================================================================
void BRepMesh_Delaun::insertInternalEdges() void BRepMesh_Delaun::insertInternalEdges()
{ {
BRepMesh::HMapOfInteger anInternalEdges = InternalEdges(); Handle(IMeshData::MapOfInteger) anInternalEdges = InternalEdges();;
// Destruction of triancles intersecting internal edges // Destruction of triancles intersecting internal edges
// and their replacement by makeshift triangles // and their replacement by makeshift triangles
Standard_Integer e[3]; IMeshData::IteratorOfMapOfInteger anInernalEdgesIt( *anInternalEdges );
Standard_Boolean o[3];
BRepMesh::MapOfInteger::Iterator anInernalEdgesIt( *anInternalEdges );
for ( ; anInernalEdgesIt.More(); anInernalEdgesIt.Next() ) for ( ; anInernalEdgesIt.More(); anInernalEdgesIt.Next() )
{ {
const Standard_Integer aLinkIndex = anInernalEdgesIt.Key(); const Standard_Integer aLinkIndex = anInernalEdgesIt.Key();
@@ -537,7 +532,10 @@ void BRepMesh_Delaun::insertInternalEdges()
Standard_Boolean isGo[2] = { Standard_True, Standard_True }; Standard_Boolean isGo[2] = { Standard_True, Standard_True };
for (Standard_Integer aTriangleIt = 1; aTriangleIt <= aPair.Extent(); ++aTriangleIt) for (Standard_Integer aTriangleIt = 1; aTriangleIt <= aPair.Extent(); ++aTriangleIt)
{ {
GetTriangle(aPair.Index(aTriangleIt)).Edges(e, o); const BRepMesh_Triangle& aElement = GetTriangle(aPair.Index(aTriangleIt));
const Standard_Integer(&e)[3] = aElement.myEdges;
const Standard_Boolean(&o)[3] = aElement.myOrientations;
for (Standard_Integer i = 0; i < 3; ++i) for (Standard_Integer i = 0; i < 3; ++i)
{ {
if (e[i] == aLinkIndex) if (e[i] == aLinkIndex)
@@ -586,9 +584,8 @@ Standard_Boolean BRepMesh_Delaun::isBoundToFrontier(
if ( aTriId < 0 || aTriId == thePrevElementId ) if ( aTriId < 0 || aTriId == thePrevElementId )
continue; continue;
Standard_Integer anEdges[3]; const BRepMesh_Triangle& aElement = GetTriangle(aTriId);
Standard_Boolean anEdgesOri[3]; const Standard_Integer(&anEdges)[3] = aElement.myEdges;
GetTriangle( aTriId ).Edges( anEdges, anEdgesOri );
for ( Standard_Integer anEdgeIt = 0; anEdgeIt < 3; ++anEdgeIt ) for ( Standard_Integer anEdgeIt = 0; anEdgeIt < 3; ++anEdgeIt )
{ {
@@ -623,16 +620,16 @@ Standard_Boolean BRepMesh_Delaun::isBoundToFrontier(
void BRepMesh_Delaun::cleanupMesh() void BRepMesh_Delaun::cleanupMesh()
{ {
Handle(NCollection_IncAllocator) aAllocator = Handle(NCollection_IncAllocator) aAllocator =
new NCollection_IncAllocator(BRepMesh::MEMORY_BLOCK_SIZE_HUGE); new NCollection_IncAllocator(IMeshData::MEMORY_BLOCK_SIZE_HUGE);
for(;;) for(;;)
{ {
aAllocator->Reset(Standard_False); aAllocator->Reset(Standard_False);
BRepMesh::MapOfIntegerInteger aLoopEdges(10, aAllocator); IMeshData::MapOfIntegerInteger aLoopEdges(10, aAllocator);
BRepMesh::MapOfInteger aDelTriangles(10, aAllocator); IMeshData::MapOfInteger aDelTriangles;
BRepMesh::HMapOfInteger aFreeEdges = FreeEdges(); Handle(IMeshData::MapOfInteger) aFreeEdges = FreeEdges();
BRepMesh::MapOfInteger::Iterator aFreeEdgesIt( *aFreeEdges ); IMeshData::IteratorOfMapOfInteger aFreeEdgesIt( *aFreeEdges );
for ( ; aFreeEdgesIt.More(); aFreeEdgesIt.Next() ) for ( ; aFreeEdgesIt.More(); aFreeEdgesIt.Next() )
{ {
const Standard_Integer& aFreeEdgeId = aFreeEdgesIt.Key(); const Standard_Integer& aFreeEdgeId = aFreeEdgesIt.Key();
@@ -651,9 +648,8 @@ void BRepMesh_Delaun::cleanupMesh()
Standard_Integer aTriId = aPair.FirstIndex(); Standard_Integer aTriId = aPair.FirstIndex();
// Check that the connected triangle is not surrounded by another triangles // Check that the connected triangle is not surrounded by another triangles
Standard_Integer anEdges[3]; const BRepMesh_Triangle& aElement = GetTriangle(aTriId);
Standard_Boolean anEdgesOri[3]; const Standard_Integer(&anEdges)[3] = aElement.myEdges;
GetTriangle( aTriId ).Edges( anEdges, anEdgesOri );
Standard_Boolean isCanNotBeRemoved = Standard_True; Standard_Boolean isCanNotBeRemoved = Standard_True;
for ( Standard_Integer aCurEdgeIdx = 0; aCurEdgeIdx < 3; ++aCurEdgeIdx ) for ( Standard_Integer aCurEdgeIdx = 0; aCurEdgeIdx < 3; ++aCurEdgeIdx )
@@ -694,7 +690,7 @@ void BRepMesh_Delaun::cleanupMesh()
// Destruction of triangles : // Destruction of triangles :
Standard_Integer aDeletedTrianglesNb = 0; Standard_Integer aDeletedTrianglesNb = 0;
BRepMesh::MapOfInteger::Iterator aDelTrianglesIt( aDelTriangles ); IMeshData::IteratorOfMapOfInteger aDelTrianglesIt( aDelTriangles );
for ( ; aDelTrianglesIt.More(); aDelTrianglesIt.Next() ) for ( ; aDelTrianglesIt.More(); aDelTrianglesIt.Next() )
{ {
deleteTriangle( aDelTrianglesIt.Key(), aLoopEdges ); deleteTriangle( aDelTrianglesIt.Key(), aLoopEdges );
@@ -702,7 +698,7 @@ void BRepMesh_Delaun::cleanupMesh()
} }
// Destruction of remaining hanging edges // Destruction of remaining hanging edges
BRepMesh::MapOfIntegerInteger::Iterator aLoopEdgesIt( aLoopEdges ); IMeshData::MapOfIntegerInteger::Iterator aLoopEdgesIt( aLoopEdges );
for ( ; aLoopEdgesIt.More(); aLoopEdgesIt.Next() ) for ( ; aLoopEdgesIt.More(); aLoopEdgesIt.Next() )
{ {
if ( myMeshData->ElementsConnectedTo( aLoopEdgesIt.Key() ).IsEmpty() ) if ( myMeshData->ElementsConnectedTo( aLoopEdgesIt.Key() ).IsEmpty() )
@@ -720,15 +716,14 @@ void BRepMesh_Delaun::cleanupMesh()
//======================================================================= //=======================================================================
void BRepMesh_Delaun::frontierAdjust() void BRepMesh_Delaun::frontierAdjust()
{ {
BRepMesh::HMapOfInteger aFrontier = Frontier(); Handle(IMeshData::MapOfInteger) aFrontier = Frontier();
Handle(NCollection_IncAllocator) aAllocator = Handle(NCollection_IncAllocator) aAllocator =
new NCollection_IncAllocator(BRepMesh::MEMORY_BLOCK_SIZE_HUGE); new NCollection_IncAllocator(IMeshData::MEMORY_BLOCK_SIZE_HUGE);
BRepMesh::VectorOfInteger aFailedFrontiers(256, aAllocator); IMeshData::VectorOfInteger aFailedFrontiers(256, aAllocator);
BRepMesh::MapOfIntegerInteger aLoopEdges(10, aAllocator); IMeshData::MapOfIntegerInteger aLoopEdges(10, aAllocator);
BRepMesh::HMapOfInteger aIntFrontierEdges = Handle(IMeshData::MapOfInteger) aIntFrontierEdges = new IMeshData::MapOfInteger;
new BRepMesh::MapOfInteger(10, aAllocator);
for ( Standard_Integer aPass = 1; aPass <= 2; ++aPass ) for ( Standard_Integer aPass = 1; aPass <= 2; ++aPass )
{ {
@@ -736,7 +731,7 @@ void BRepMesh_Delaun::frontierAdjust()
// 2 pass): find external triangles on boundary edges appeared // 2 pass): find external triangles on boundary edges appeared
// during triangles replacement. // during triangles replacement.
BRepMesh::MapOfInteger::Iterator aFrontierIt( *aFrontier ); IMeshData::IteratorOfMapOfInteger aFrontierIt( *aFrontier );
for ( ; aFrontierIt.More(); aFrontierIt.Next() ) for ( ; aFrontierIt.More(); aFrontierIt.Next() )
{ {
Standard_Integer aFrontierId = aFrontierIt.Key(); Standard_Integer aFrontierId = aFrontierIt.Key();
@@ -748,9 +743,9 @@ void BRepMesh_Delaun::frontierAdjust()
if( aPriorElemId < 0 ) if( aPriorElemId < 0 )
continue; continue;
Standard_Integer e[3]; const BRepMesh_Triangle& aElement = GetTriangle(aPriorElemId);
Standard_Boolean o[3]; const Standard_Integer(&e)[3] = aElement.myEdges;
GetTriangle( aPriorElemId ).Edges( e, o ); const Standard_Boolean(&o)[3] = aElement.myOrientations;
Standard_Boolean isTriangleFound = Standard_False; Standard_Boolean isTriangleFound = Standard_False;
for ( Standard_Integer n = 0; n < 3; ++n ) for ( Standard_Integer n = 0; n < 3; ++n )
@@ -770,7 +765,7 @@ void BRepMesh_Delaun::frontierAdjust()
} }
// destrucrion of remaining hanging edges : // destrucrion of remaining hanging edges :
BRepMesh::MapOfIntegerInteger::Iterator aLoopEdgesIt( aLoopEdges ); IMeshData::MapOfIntegerInteger::Iterator aLoopEdgesIt( aLoopEdges );
for ( ; aLoopEdgesIt.More(); aLoopEdgesIt.Next() ) for ( ; aLoopEdgesIt.More(); aLoopEdgesIt.Next() )
{ {
Standard_Integer aLoopEdgeId = aLoopEdgesIt.Key(); Standard_Integer aLoopEdgeId = aLoopEdgesIt.Key();
@@ -801,7 +796,7 @@ void BRepMesh_Delaun::frontierAdjust()
// situation when frontier edge has a triangle at a right side, but its free // situation when frontier edge has a triangle at a right side, but its free
// links cross another frontieres and meshLeftPolygonOf itself can't collect // links cross another frontieres and meshLeftPolygonOf itself can't collect
// a closed polygon. // a closed polygon.
BRepMesh::VectorOfInteger::Iterator aFailedFrontiersIt( aFailedFrontiers ); IMeshData::VectorOfInteger::Iterator aFailedFrontiersIt( aFailedFrontiers );
for ( ; aFailedFrontiersIt.More(); aFailedFrontiersIt.Next() ) for ( ; aFailedFrontiersIt.More(); aFailedFrontiersIt.Next() )
{ {
Standard_Integer aFrontierId = aFailedFrontiersIt.Value(); Standard_Integer aFrontierId = aFailedFrontiersIt.Value();
@@ -817,7 +812,7 @@ void BRepMesh_Delaun::frontierAdjust()
//purpose : Add boundig box for edge defined by start & end point to //purpose : Add boundig box for edge defined by start & end point to
// the given vector of bounding boxes for triangulation edges // the given vector of bounding boxes for triangulation edges
//======================================================================= //=======================================================================
void BRepMesh_Delaun::fillBndBox(BRepMesh::SequenceOfBndB2d& theBoxes, void BRepMesh_Delaun::fillBndBox(IMeshData::SequenceOfBndB2d& theBoxes,
const BRepMesh_Vertex& theV1, const BRepMesh_Vertex& theV1,
const BRepMesh_Vertex& theV2) const BRepMesh_Vertex& theV2)
{ {
@@ -833,14 +828,14 @@ void BRepMesh_Delaun::fillBndBox(BRepMesh::SequenceOfBndB2d& theBoxes,
Standard_Boolean BRepMesh_Delaun::meshLeftPolygonOf( Standard_Boolean BRepMesh_Delaun::meshLeftPolygonOf(
const Standard_Integer theStartEdgeId, const Standard_Integer theStartEdgeId,
const Standard_Boolean isForward, const Standard_Boolean isForward,
BRepMesh::HMapOfInteger theSkipped ) Handle(IMeshData::MapOfInteger) theSkipped)
{ {
if ( !theSkipped.IsNull() && theSkipped->Contains( theStartEdgeId ) ) if ( !theSkipped.IsNull() && theSkipped->Contains( theStartEdgeId ) )
return Standard_True; return Standard_True;
const BRepMesh_Edge& aRefEdge = GetEdge( theStartEdgeId ); const BRepMesh_Edge& aRefEdge = GetEdge( theStartEdgeId );
BRepMesh::SequenceOfInteger aPolygon; IMeshData::SequenceOfInteger aPolygon;
Standard_Integer aStartNode, aPivotNode; Standard_Integer aStartNode, aPivotNode;
if ( isForward ) if ( isForward )
{ {
@@ -868,14 +863,14 @@ Standard_Boolean BRepMesh_Delaun::meshLeftPolygonOf(
// Auxilary structures. // Auxilary structures.
// Bounding boxes of polygon links to be used for preliminary // Bounding boxes of polygon links to be used for preliminary
// analysis of intersections // analysis of intersections
BRepMesh::SequenceOfBndB2d aBoxes; IMeshData::SequenceOfBndB2d aBoxes;
fillBndBox( aBoxes, aStartEdgeVertexS, aPivotVertex ); fillBndBox( aBoxes, aStartEdgeVertexS, aPivotVertex );
// Hanging ends // Hanging ends
BRepMesh::MapOfInteger aDeadLinks; IMeshData::MapOfInteger aDeadLinks;
// Links are temporarily excluded from consideration // Links are temporarily excluded from consideration
BRepMesh::MapOfInteger aLeprousLinks; IMeshData::MapOfInteger aLeprousLinks;
aLeprousLinks.Add( theStartEdgeId ); aLeprousLinks.Add( theStartEdgeId );
Standard_Boolean isSkipLeprous = Standard_True; Standard_Boolean isSkipLeprous = Standard_True;
@@ -964,12 +959,12 @@ Standard_Integer BRepMesh_Delaun::findNextPolygonLink(
const Standard_Integer& thePivotNode, const Standard_Integer& thePivotNode,
const BRepMesh_Vertex& thePivotVertex, const BRepMesh_Vertex& thePivotVertex,
const gp_Vec2d& theRefLinkDir, const gp_Vec2d& theRefLinkDir,
const BRepMesh::SequenceOfBndB2d& theBoxes, const IMeshData::SequenceOfBndB2d& theBoxes,
const BRepMesh::SequenceOfInteger& thePolygon, const IMeshData::SequenceOfInteger& thePolygon,
const BRepMesh::HMapOfInteger theSkipped, const Handle(IMeshData::MapOfInteger) theSkipped,
const Standard_Boolean& isSkipLeprous, const Standard_Boolean& isSkipLeprous,
BRepMesh::MapOfInteger& theLeprousLinks, IMeshData::MapOfInteger& theLeprousLinks,
BRepMesh::MapOfInteger& theDeadLinks, IMeshData::MapOfInteger& theDeadLinks,
Standard_Integer& theNextPivotNode, Standard_Integer& theNextPivotNode,
gp_Vec2d& theNextLinkDir, gp_Vec2d& theNextLinkDir,
Bnd_B2d& theNextLinkBndBox ) Bnd_B2d& theNextLinkBndBox )
@@ -979,7 +974,7 @@ Standard_Integer BRepMesh_Delaun::findNextPolygonLink(
Standard_Real aMaxAngle = RealFirst(); Standard_Real aMaxAngle = RealFirst();
Standard_Integer aNextLinkId = 0; Standard_Integer aNextLinkId = 0;
BRepMesh::ListOfInteger::Iterator aLinkIt( myMeshData->LinksConnectedTo( thePivotNode ) ); IMeshData::ListOfInteger::Iterator aLinkIt( myMeshData->LinksConnectedTo( thePivotNode ) );
for ( ; aLinkIt.More(); aLinkIt.Next() ) for ( ; aLinkIt.More(); aLinkIt.Next() )
{ {
const Standard_Integer& aNeighbourLinkInfo = aLinkIt.Value(); const Standard_Integer& aNeighbourLinkInfo = aLinkIt.Value();
@@ -1070,8 +1065,8 @@ Standard_Integer BRepMesh_Delaun::findNextPolygonLink(
//======================================================================= //=======================================================================
Standard_Boolean BRepMesh_Delaun::checkIntersection( Standard_Boolean BRepMesh_Delaun::checkIntersection(
const BRepMesh_Edge& theLink, const BRepMesh_Edge& theLink,
const BRepMesh::SequenceOfInteger& thePolygon, const IMeshData::SequenceOfInteger& thePolygon,
const BRepMesh::SequenceOfBndB2d& thePolyBoxes, const IMeshData::SequenceOfBndB2d& thePolyBoxes,
const Standard_Boolean isConsiderEndPointTouch, const Standard_Boolean isConsiderEndPointTouch,
const Standard_Boolean isConsiderPointOnEdge, const Standard_Boolean isConsiderPointOnEdge,
const Standard_Boolean isSkipLastEdge, const Standard_Boolean isSkipLastEdge,
@@ -1117,17 +1112,10 @@ Standard_Boolean BRepMesh_Delaun::checkIntersection(
//function : addTriangle //function : addTriangle
//purpose : Add a triangle based on the given oriented edges into mesh //purpose : Add a triangle based on the given oriented edges into mesh
//======================================================================= //=======================================================================
void BRepMesh_Delaun::addTriangle( const Standard_Integer (&theEdgesId)[3], inline void BRepMesh_Delaun::addTriangle( const Standard_Integer (&theEdgesId)[3],
const Standard_Boolean (&theEdgesOri)[3], const Standard_Boolean (&theEdgesOri)[3],
const Standard_Integer (&theNodesId)[3]) const Standard_Integer (&theNodesId)[3] )
{ {
for (Standard_Integer i = 0; i < 3; ++i)
{
const BRepMesh_PairOfIndex& aPair = myMeshData->ElementsConnectedTo(theEdgesId[i]);
if (aPair.Extent() == 2)
// it is forbidden to have more than two triangles connected to the same link
return;
}
Standard_Integer aNewTriangleId = Standard_Integer aNewTriangleId =
myMeshData->AddElement(BRepMesh_Triangle(theEdgesId, myMeshData->AddElement(BRepMesh_Triangle(theEdgesId,
theEdgesOri, BRepMesh_Free)); theEdgesOri, BRepMesh_Free));
@@ -1146,20 +1134,20 @@ void BRepMesh_Delaun::addTriangle( const Standard_Integer (&theEdgesId)[3],
//function : cleanupPolygon //function : cleanupPolygon
//purpose : Remove internal triangles from the given polygon //purpose : Remove internal triangles from the given polygon
//======================================================================= //=======================================================================
void BRepMesh_Delaun::cleanupPolygon(const BRepMesh::SequenceOfInteger& thePolygon, void BRepMesh_Delaun::cleanupPolygon(const IMeshData::SequenceOfInteger& thePolygon,
const BRepMesh::SequenceOfBndB2d& thePolyBoxes ) const IMeshData::SequenceOfBndB2d& thePolyBoxes )
{ {
Standard_Integer aPolyLen = thePolygon.Length(); Standard_Integer aPolyLen = thePolygon.Length();
if ( aPolyLen < 3 ) if ( aPolyLen < 3 )
return; return;
Handle(NCollection_IncAllocator) aAllocator = Handle(NCollection_IncAllocator) aAllocator =
new NCollection_IncAllocator(BRepMesh::MEMORY_BLOCK_SIZE_HUGE); new NCollection_IncAllocator(IMeshData::MEMORY_BLOCK_SIZE_HUGE);
BRepMesh::MapOfIntegerInteger aLoopEdges(10, aAllocator); IMeshData::MapOfIntegerInteger aLoopEdges(10, aAllocator);
BRepMesh::MapOfInteger anIgnoredEdges(10, aAllocator); IMeshData::MapOfInteger anIgnoredEdges;
BRepMesh::MapOfInteger aPolyVerticesFindMap(10, aAllocator); IMeshData::MapOfInteger aPolyVerticesFindMap;
BRepMesh::VectorOfInteger aPolyVertices(256, aAllocator); IMeshData::VectorOfInteger aPolyVertices(256, aAllocator);
// Collect boundary vertices of the polygon // Collect boundary vertices of the polygon
for ( Standard_Integer aPolyIt = 1; aPolyIt <= aPolyLen; ++aPolyIt ) for ( Standard_Integer aPolyIt = 1; aPolyIt <= aPolyLen; ++aPolyIt )
{ {
@@ -1178,9 +1166,9 @@ void BRepMesh_Delaun::cleanupPolygon(const BRepMesh::SequenceOfInteger& thePolyg
if ( anElemId < 0 ) if ( anElemId < 0 )
continue; continue;
Standard_Integer anEdges[3]; const BRepMesh_Triangle& aElement = GetTriangle(anElemId);
Standard_Boolean anEdgesOri[3]; const Standard_Integer(&anEdges)[3] = aElement.myEdges;
GetTriangle( anElemId ).Edges(anEdges, anEdgesOri); const Standard_Boolean(&anEdgesOri)[3] = aElement.myOrientations;
Standard_Integer isTriangleFound = Standard_False; Standard_Integer isTriangleFound = Standard_False;
for ( Standard_Integer anEdgeIt = 0; anEdgeIt < 3; ++anEdgeIt ) for ( Standard_Integer anEdgeIt = 0; anEdgeIt < 3; ++anEdgeIt )
@@ -1225,7 +1213,7 @@ void BRepMesh_Delaun::cleanupPolygon(const BRepMesh::SequenceOfInteger& thePolyg
if ( aPolyVertices.First() != aPolyVertices.Last() ) if ( aPolyVertices.First() != aPolyVertices.Last() )
aPolyVertices.Append( aPolyVertices.First() ); aPolyVertices.Append( aPolyVertices.First() );
BRepMesh::MapOfInteger aSurvivedLinks( anIgnoredEdges ); IMeshData::MapOfInteger aSurvivedLinks( anIgnoredEdges );
Standard_Integer aPolyVertIt = 0; Standard_Integer aPolyVertIt = 0;
Standard_Integer anUniqueVerticesNum = aPolyVertices.Length() - 1; Standard_Integer anUniqueVerticesNum = aPolyVertices.Length() - 1;
@@ -1236,7 +1224,7 @@ void BRepMesh_Delaun::cleanupPolygon(const BRepMesh::SequenceOfInteger& thePolyg
thePolyBoxes, aSurvivedLinks, aLoopEdges ); thePolyBoxes, aSurvivedLinks, aLoopEdges );
} }
BRepMesh::MapOfIntegerInteger::Iterator aLoopEdgesIt( aLoopEdges ); IMeshData::MapOfIntegerInteger::Iterator aLoopEdgesIt( aLoopEdges );
for ( ; aLoopEdgesIt.More(); aLoopEdgesIt.Next() ) for ( ; aLoopEdgesIt.More(); aLoopEdgesIt.Next() )
{ {
const Standard_Integer& aLoopEdgeId = aLoopEdgesIt.Key(); const Standard_Integer& aLoopEdgeId = aLoopEdgesIt.Key();
@@ -1255,18 +1243,18 @@ void BRepMesh_Delaun::cleanupPolygon(const BRepMesh::SequenceOfInteger& thePolyg
//======================================================================= //=======================================================================
void BRepMesh_Delaun::killTrianglesAroundVertex( void BRepMesh_Delaun::killTrianglesAroundVertex(
const Standard_Integer theZombieNodeId, const Standard_Integer theZombieNodeId,
const BRepMesh::VectorOfInteger& thePolyVertices, const IMeshData::VectorOfInteger& thePolyVertices,
const BRepMesh::MapOfInteger& thePolyVerticesFindMap, const IMeshData::MapOfInteger& thePolyVerticesFindMap,
const BRepMesh::SequenceOfInteger& thePolygon, const IMeshData::SequenceOfInteger& thePolygon,
const BRepMesh::SequenceOfBndB2d& thePolyBoxes, const IMeshData::SequenceOfBndB2d& thePolyBoxes,
BRepMesh::MapOfInteger& theSurvivedLinks, IMeshData::MapOfInteger& theSurvivedLinks,
BRepMesh::MapOfIntegerInteger& theLoopEdges ) IMeshData::MapOfIntegerInteger& theLoopEdges )
{ {
BRepMesh::ListOfInteger::Iterator aNeighborsIt = IMeshData::ListOfInteger::Iterator aNeighborsIt =
myMeshData->LinksConnectedTo( theZombieNodeId ); myMeshData->LinksConnectedTo( theZombieNodeId );
// Try to infect neighbor nodes // Try to infect neighbor nodes
BRepMesh::VectorOfInteger aVictimNodes; IMeshData::VectorOfInteger aVictimNodes;
for ( ; aNeighborsIt.More(); aNeighborsIt.Next() ) for ( ; aNeighborsIt.More(); aNeighborsIt.Next() )
{ {
const Standard_Integer& aNeighborLinkId = aNeighborsIt.Value(); const Standard_Integer& aNeighborLinkId = aNeighborsIt.Value();
@@ -1324,7 +1312,7 @@ void BRepMesh_Delaun::killTrianglesAroundVertex(
} }
// Go and do your job! // Go and do your job!
BRepMesh::VectorOfInteger::Iterator aVictimIt( aVictimNodes ); IMeshData::VectorOfInteger::Iterator aVictimIt( aVictimNodes );
for ( ; aVictimIt.More(); aVictimIt.Next() ) for ( ; aVictimIt.More(); aVictimIt.Next() )
{ {
killTrianglesAroundVertex( aVictimIt.Value(), thePolyVertices, killTrianglesAroundVertex( aVictimIt.Value(), thePolyVertices,
@@ -1339,7 +1327,7 @@ void BRepMesh_Delaun::killTrianglesAroundVertex(
//======================================================================= //=======================================================================
Standard_Boolean BRepMesh_Delaun::isVertexInsidePolygon( Standard_Boolean BRepMesh_Delaun::isVertexInsidePolygon(
const Standard_Integer& theVertexId, const Standard_Integer& theVertexId,
const BRepMesh::VectorOfInteger& thePolygonVertices ) const const IMeshData::VectorOfInteger& thePolygonVertices ) const
{ {
Standard_Integer aPolyLen = thePolygonVertices.Length(); Standard_Integer aPolyLen = thePolygonVertices.Length();
if ( aPolyLen < 3 ) if ( aPolyLen < 3 )
@@ -1382,10 +1370,10 @@ void BRepMesh_Delaun::killTrianglesOnIntersectingLinks(
const Standard_Integer& theLinkToCheckId, const Standard_Integer& theLinkToCheckId,
const BRepMesh_Edge& theLinkToCheck, const BRepMesh_Edge& theLinkToCheck,
const Standard_Integer& theEndPoint, const Standard_Integer& theEndPoint,
const BRepMesh::SequenceOfInteger& thePolygon, const IMeshData::SequenceOfInteger& thePolygon,
const BRepMesh::SequenceOfBndB2d& thePolyBoxes, const IMeshData::SequenceOfBndB2d& thePolyBoxes,
BRepMesh::MapOfInteger& theSurvivedLinks, IMeshData::MapOfInteger& theSurvivedLinks,
BRepMesh::MapOfIntegerInteger& theLoopEdges ) IMeshData::MapOfIntegerInteger& theLoopEdges )
{ {
if ( theSurvivedLinks.Contains( theLinkToCheckId ) ) if ( theSurvivedLinks.Contains( theLinkToCheckId ) )
return; return;
@@ -1403,7 +1391,7 @@ void BRepMesh_Delaun::killTrianglesOnIntersectingLinks(
killLinkTriangles( theLinkToCheckId, theLoopEdges ); killLinkTriangles( theLinkToCheckId, theLoopEdges );
BRepMesh::ListOfInteger::Iterator aNeighborsIt( IMeshData::ListOfInteger::Iterator aNeighborsIt(
myMeshData->LinksConnectedTo(theEndPoint)); myMeshData->LinksConnectedTo(theEndPoint));
for ( ; aNeighborsIt.More(); aNeighborsIt.Next() ) for ( ; aNeighborsIt.More(); aNeighborsIt.Next() )
@@ -1426,7 +1414,7 @@ void BRepMesh_Delaun::killTrianglesOnIntersectingLinks(
//======================================================================= //=======================================================================
void BRepMesh_Delaun::killLinkTriangles( void BRepMesh_Delaun::killLinkTriangles(
const Standard_Integer& theLinkId, const Standard_Integer& theLinkId,
BRepMesh::MapOfIntegerInteger& theLoopEdges ) IMeshData::MapOfIntegerInteger& theLoopEdges )
{ {
const BRepMesh_PairOfIndex& aPair = const BRepMesh_PairOfIndex& aPair =
myMeshData->ElementsConnectedTo( theLinkId ); myMeshData->ElementsConnectedTo( theLinkId );
@@ -1470,15 +1458,15 @@ void BRepMesh_Delaun::getOrientedNodes(const BRepMesh_Edge& theEdge,
//======================================================================= //=======================================================================
void BRepMesh_Delaun::processLoop(const Standard_Integer theLinkFrom, void BRepMesh_Delaun::processLoop(const Standard_Integer theLinkFrom,
const Standard_Integer theLinkTo, const Standard_Integer theLinkTo,
const BRepMesh::SequenceOfInteger& thePolygon, const IMeshData::SequenceOfInteger& thePolygon,
const BRepMesh::SequenceOfBndB2d& thePolyBoxes) const IMeshData::SequenceOfBndB2d& thePolyBoxes)
{ {
Standard_Integer aNbOfLinksInLoop = theLinkTo - theLinkFrom - 1; Standard_Integer aNbOfLinksInLoop = theLinkTo - theLinkFrom - 1;
if ( aNbOfLinksInLoop < 3 ) if ( aNbOfLinksInLoop < 3 )
return; return;
BRepMesh::SequenceOfInteger aPolygon; IMeshData::SequenceOfInteger aPolygon;
BRepMesh::SequenceOfBndB2d aPolyBoxes; IMeshData::SequenceOfBndB2d aPolyBoxes;
for ( ; aNbOfLinksInLoop > 0; --aNbOfLinksInLoop ) for ( ; aNbOfLinksInLoop > 0; --aNbOfLinksInLoop )
{ {
Standard_Integer aLoopLinkIndex = theLinkFrom + aNbOfLinksInLoop; Standard_Integer aLoopLinkIndex = theLinkFrom + aNbOfLinksInLoop;
@@ -1498,8 +1486,8 @@ Standard_Integer BRepMesh_Delaun::createAndReplacePolygonLink(
const gp_Pnt2d *thePnts, const gp_Pnt2d *thePnts,
const Standard_Integer theRootIndex, const Standard_Integer theRootIndex,
const ReplaceFlag theReplaceFlag, const ReplaceFlag theReplaceFlag,
BRepMesh::SequenceOfInteger& thePolygon, IMeshData::SequenceOfInteger& thePolygon,
BRepMesh::SequenceOfBndB2d& thePolyBoxes ) IMeshData::SequenceOfBndB2d& thePolyBoxes )
{ {
Standard_Integer aNewEdgeId = Standard_Integer aNewEdgeId =
myMeshData->AddLink( BRepMesh_Edge( myMeshData->AddLink( BRepMesh_Edge(
@@ -1533,9 +1521,9 @@ Standard_Integer BRepMesh_Delaun::createAndReplacePolygonLink(
//function : meshPolygon //function : meshPolygon
//purpose : //purpose :
//======================================================================= //=======================================================================
void BRepMesh_Delaun::meshPolygon(BRepMesh::SequenceOfInteger& thePolygon, void BRepMesh_Delaun::meshPolygon(IMeshData::SequenceOfInteger& thePolygon,
BRepMesh::SequenceOfBndB2d& thePolyBoxes, IMeshData::SequenceOfBndB2d& thePolyBoxes,
BRepMesh::HMapOfInteger theSkipped ) Handle(IMeshData::MapOfInteger) theSkipped)
{ {
// Check is the source polygon elementary // Check is the source polygon elementary
if ( meshElementaryPolygon( thePolygon ) ) if ( meshElementaryPolygon( thePolygon ) )
@@ -1749,14 +1737,14 @@ void BRepMesh_Delaun::meshPolygon(BRepMesh::SequenceOfInteger& thePolygon,
} }
} }
BRepMesh::SequenceOfInteger* aPolygon1 = &thePolygon; IMeshData::SequenceOfInteger* aPolygon1 = &thePolygon;
BRepMesh::SequenceOfBndB2d* aPolyBoxes1 = &thePolyBoxes; IMeshData::SequenceOfBndB2d* aPolyBoxes1 = &thePolyBoxes;
BRepMesh::HSequenceOfInteger aPolygon2 = new BRepMesh::SequenceOfInteger; Handle(IMeshData::SequenceOfInteger) aPolygon2 = new IMeshData::SequenceOfInteger;
BRepMesh::HSequenceOfBndB2d aPolyBoxes2 = new BRepMesh::SequenceOfBndB2d; Handle(IMeshData::SequenceOfBndB2d) aPolyBoxes2 = new IMeshData::SequenceOfBndB2d;
NCollection_Sequence<BRepMesh::HSequenceOfInteger> aPolyStack; NCollection_Sequence<Handle(IMeshData::SequenceOfInteger)> aPolyStack;
NCollection_Sequence<BRepMesh::HSequenceOfBndB2d> aPolyBoxStack; NCollection_Sequence<Handle(IMeshData::SequenceOfBndB2d)> aPolyBoxStack;
for (;;) for (;;)
{ {
decomposeSimplePolygon(*aPolygon1, *aPolyBoxes1, *aPolygon2, *aPolyBoxes2); decomposeSimplePolygon(*aPolygon1, *aPolyBoxes1, *aPolygon2, *aPolyBoxes2);
@@ -1765,8 +1753,8 @@ void BRepMesh_Delaun::meshPolygon(BRepMesh::SequenceOfInteger& thePolygon,
aPolyStack.Append(aPolygon2); aPolyStack.Append(aPolygon2);
aPolyBoxStack.Append(aPolyBoxes2); aPolyBoxStack.Append(aPolyBoxes2);
aPolygon2 = new BRepMesh::SequenceOfInteger; aPolygon2 = new IMeshData::SequenceOfInteger;
aPolyBoxes2 = new BRepMesh::SequenceOfBndB2d; aPolyBoxes2 = new IMeshData::SequenceOfBndB2d;
} }
if (aPolygon1->IsEmpty()) if (aPolygon1->IsEmpty())
@@ -1791,7 +1779,7 @@ void BRepMesh_Delaun::meshPolygon(BRepMesh::SequenceOfInteger& thePolygon,
//purpose : Triangulation of closed polygon containing only three edges. //purpose : Triangulation of closed polygon containing only three edges.
//======================================================================= //=======================================================================
inline Standard_Boolean BRepMesh_Delaun::meshElementaryPolygon( inline Standard_Boolean BRepMesh_Delaun::meshElementaryPolygon(
const BRepMesh::SequenceOfInteger& thePolygon) const IMeshData::SequenceOfInteger& thePolygon)
{ {
Standard_Integer aPolyLen = thePolygon.Length(); Standard_Integer aPolyLen = thePolygon.Length();
if ( aPolyLen < 3 ) if ( aPolyLen < 3 )
@@ -1831,10 +1819,10 @@ inline Standard_Boolean BRepMesh_Delaun::meshElementaryPolygon(
//purpose : //purpose :
//======================================================================= //=======================================================================
void BRepMesh_Delaun::decomposeSimplePolygon( void BRepMesh_Delaun::decomposeSimplePolygon(
BRepMesh::SequenceOfInteger& thePolygon, IMeshData::SequenceOfInteger& thePolygon,
BRepMesh::SequenceOfBndB2d& thePolyBoxes, IMeshData::SequenceOfBndB2d& thePolyBoxes,
BRepMesh::SequenceOfInteger& thePolygonCut, IMeshData::SequenceOfInteger& thePolygonCut,
BRepMesh::SequenceOfBndB2d& thePolyBoxesCut) IMeshData::SequenceOfBndB2d& thePolyBoxesCut)
{ {
// Check is the given polygon elementary // Check is the given polygon elementary
if ( meshElementaryPolygon( thePolygon ) ) if ( meshElementaryPolygon( thePolygon ) )
@@ -2018,17 +2006,17 @@ void BRepMesh_Delaun::RemoveVertex( const BRepMesh_Vertex& theVertex )
BRepMesh_SelectorOfDataStructureOfDelaun aSelector( myMeshData ); BRepMesh_SelectorOfDataStructureOfDelaun aSelector( myMeshData );
aSelector.NeighboursOf( theVertex ); aSelector.NeighboursOf( theVertex );
BRepMesh::MapOfIntegerInteger aLoopEdges;//( 10, myMeshData->Allocator() ); IMeshData::MapOfIntegerInteger aLoopEdges;//( 10, myMeshData->Allocator() );
// Loop on triangles to be destroyed : // Loop on triangles to be destroyed :
BRepMesh::MapOfInteger::Iterator aTriangleIt( aSelector.Elements() ); IMeshData::IteratorOfMapOfInteger aTriangleIt( aSelector.Elements() );
for ( ; aTriangleIt.More(); aTriangleIt.Next() ) for ( ; aTriangleIt.More(); aTriangleIt.Next() )
deleteTriangle( aTriangleIt.Key(), aLoopEdges ); deleteTriangle( aTriangleIt.Key(), aLoopEdges );
BRepMesh::SequenceOfBndB2d aBoxes; IMeshData::SequenceOfBndB2d aBoxes;
BRepMesh::SequenceOfInteger aPolygon; IMeshData::SequenceOfInteger aPolygon;
Standard_Integer aLoopEdgesCount = aLoopEdges.Extent(); Standard_Integer aLoopEdgesCount = aLoopEdges.Extent();
BRepMesh::MapOfIntegerInteger::Iterator aLoopEdgesIt( aLoopEdges ); IMeshData::MapOfIntegerInteger::Iterator aLoopEdgesIt( aLoopEdges );
if ( aLoopEdgesIt.More() ) if ( aLoopEdgesIt.More() )
{ {
@@ -2038,7 +2026,7 @@ void BRepMesh_Delaun::RemoveVertex( const BRepMesh_Vertex& theVertex )
Standard_Integer aPivotNode = anEdge.LastNode(); Standard_Integer aPivotNode = anEdge.LastNode();
Standard_Integer anEdgeId = aLoopEdgesIt.Key(); Standard_Integer anEdgeId = aLoopEdgesIt.Key();
Standard_Boolean isPositive = (aLoopEdges (anEdgeId) != 0); Standard_Boolean isPositive = aLoopEdges( anEdgeId ) != 0;
if ( !isPositive ) if ( !isPositive )
{ {
Standard_Integer aTmp; Standard_Integer aTmp;
@@ -2058,7 +2046,7 @@ void BRepMesh_Delaun::RemoveVertex( const BRepMesh_Vertex& theVertex )
aLastNode = aFirstNode; aLastNode = aFirstNode;
while ( aPivotNode != aLastNode ) while ( aPivotNode != aLastNode )
{ {
BRepMesh::ListOfInteger::Iterator aLinkIt( myMeshData->LinksConnectedTo( aPivotNode ) ); IMeshData::ListOfInteger::Iterator aLinkIt( myMeshData->LinksConnectedTo( aPivotNode ) );
for ( ; aLinkIt.More(); aLinkIt.Next() ) for ( ; aLinkIt.More(); aLinkIt.Next() )
{ {
if ( aLinkIt.Value() != anEdgeId && if ( aLinkIt.Value() != anEdgeId &&
@@ -2099,19 +2087,13 @@ void BRepMesh_Delaun::RemoveVertex( const BRepMesh_Vertex& theVertex )
//function : AddVertices //function : AddVertices
//purpose : Adds some vertices in the triangulation. //purpose : Adds some vertices in the triangulation.
//======================================================================= //=======================================================================
void BRepMesh_Delaun::AddVertices(BRepMesh::Array1OfVertexOfDelaun& theVertices) void BRepMesh_Delaun::AddVertices(IMeshData::VectorOfInteger& theVertices)
{ {
std::make_heap(theVertices.begin(), theVertices.end(), ComparatorOfVertexOfDelaun()); ComparatorOfIndexedVertexOfDelaun aCmp(myMeshData);
std::sort_heap(theVertices.begin(), theVertices.end(), ComparatorOfVertexOfDelaun()); std::make_heap(theVertices.begin(), theVertices.end(), aCmp);
std::sort_heap(theVertices.begin(), theVertices.end(), aCmp);
Standard_Integer aLower = theVertices.Lower(); createTrianglesOnNewVertices(theVertices);
Standard_Integer anUpper = theVertices.Upper();
BRepMesh::Array1OfInteger aVertexIndexes( aLower, anUpper );
for ( Standard_Integer i = aLower; i <= anUpper; ++i )
aVertexIndexes(i) = myMeshData->AddNode( theVertices(i) );
createTrianglesOnNewVertices( aVertexIndexes );
} }
//======================================================================= //=======================================================================
@@ -2206,12 +2188,12 @@ Standard_Boolean BRepMesh_Delaun::UseEdge( const Standard_Integer /*theIndex*/ )
//function : getEdgesByType //function : getEdgesByType
//purpose : Gives the list of edges with type defined by input parameter //purpose : Gives the list of edges with type defined by input parameter
//======================================================================= //=======================================================================
BRepMesh::HMapOfInteger BRepMesh_Delaun::getEdgesByType( Handle(IMeshData::MapOfInteger) BRepMesh_Delaun::getEdgesByType(
const BRepMesh_DegreeOfFreedom theEdgeType ) const const BRepMesh_DegreeOfFreedom theEdgeType ) const
{ {
Handle(NCollection_IncAllocator) anAlloc = new NCollection_IncAllocator; Handle(NCollection_IncAllocator) anAlloc = new NCollection_IncAllocator;
BRepMesh::HMapOfInteger aResult = new BRepMesh::MapOfInteger(1, anAlloc); Handle(IMeshData::MapOfInteger) aResult = new IMeshData::MapOfInteger;
BRepMesh::MapOfInteger::Iterator anEdgeIt( myMeshData->LinksOfDomain() ); IMeshData::IteratorOfMapOfInteger anEdgeIt( myMeshData->LinksOfDomain() );
for ( ; anEdgeIt.More(); anEdgeIt.Next() ) for ( ; anEdgeIt.More(); anEdgeIt.Next() )
{ {
@@ -2274,12 +2256,10 @@ Standard_Boolean BRepMesh_Delaun::Contains( const Standard_Integer theTriangleId
{ {
theEdgeOn = 0; theEdgeOn = 0;
Standard_Integer e[3];
Standard_Boolean o[3];
Standard_Integer p[3]; Standard_Integer p[3];
const BRepMesh_Triangle& aElement = GetTriangle( theTriangleId ); const BRepMesh_Triangle& aElement = GetTriangle( theTriangleId );
aElement.Edges(e, o); const Standard_Integer(&e)[3] = aElement.myEdges;
const BRepMesh_Edge* anEdges[3] = { &GetEdge( e[0] ), const BRepMesh_Edge* anEdges[3] = { &GetEdge( e[0] ),
&GetEdge( e[1] ), &GetEdge( e[1] ),
@@ -2351,7 +2331,7 @@ BRepMesh_GeomTool::IntFlag BRepMesh_Delaun::intSegSeg(
//purpose : Returns area of the loop of the given polygon defined by indices //purpose : Returns area of the loop of the given polygon defined by indices
// of its start and end links. // of its start and end links.
//============================================================================= //=============================================================================
Standard_Real BRepMesh_Delaun::polyArea(const BRepMesh::SequenceOfInteger& thePolygon, Standard_Real BRepMesh_Delaun::polyArea(const IMeshData::SequenceOfInteger& thePolygon,
const Standard_Integer theStartIndex, const Standard_Integer theStartIndex,
const Standard_Integer theEndIndex) const const Standard_Integer theEndIndex) const
{ {
@@ -2406,7 +2386,7 @@ Standard_CString BRepMesh_DumpPoly(void* thePolygon,
return "Error: file name or polygon data is null"; return "Error: file name or polygon data is null";
} }
BRepMesh::SequenceOfInteger& aPolygon = *(BRepMesh::SequenceOfInteger*)thePolygon; IMeshData::SequenceOfInteger& aPolygon = *(IMeshData::SequenceOfInteger*)thePolygon;
Handle(BRepMesh_DataStructureOfDelaun) aMeshData = Handle(BRepMesh_DataStructureOfDelaun) aMeshData =
*(Handle(BRepMesh_DataStructureOfDelaun)*)theMeshHandlePtr; *(Handle(BRepMesh_DataStructureOfDelaun)*)theMeshHandlePtr;
@@ -2422,7 +2402,7 @@ Standard_CString BRepMesh_DumpPoly(void* thePolygon,
{ {
OCC_CATCH_SIGNALS OCC_CATCH_SIGNALS
BRepMesh::SequenceOfInteger::Iterator aLinksIt(aPolygon); IMeshData::SequenceOfInteger::Iterator aLinksIt(aPolygon);
for (; aLinksIt.More(); aLinksIt.Next()) for (; aLinksIt.More(); aLinksIt.Next())
{ {
const BRepMesh_Edge& aLink = aMeshData->GetLink(Abs(aLinksIt.Value())); const BRepMesh_Edge& aLink = aMeshData->GetLink(Abs(aLinksIt.Value()));

106
src/BRepMesh/BRepMesh_Delaun.hxx
View File

@@ -23,7 +23,7 @@
#include <BRepMesh_CircleTool.hxx> #include <BRepMesh_CircleTool.hxx>
#include <BRepMesh_Triangle.hxx> #include <BRepMesh_Triangle.hxx>
#include <BRepMesh_Edge.hxx> #include <BRepMesh_Edge.hxx>
#include <BRepMesh.hxx> #include <IMeshData_Types.hxx>
#include <BRepMesh_DataStructureOfDelaun.hxx> #include <BRepMesh_DataStructureOfDelaun.hxx>
#include <BRepMesh_GeomTool.hxx> #include <BRepMesh_GeomTool.hxx>
#include <TColStd_Array1OfInteger.hxx> #include <TColStd_Array1OfInteger.hxx>
@@ -42,24 +42,24 @@ public:
DEFINE_STANDARD_ALLOC DEFINE_STANDARD_ALLOC
//! Creates the triangulation with an empty Mesh data structure. //! Creates the triangulation with an empty Mesh data structure.
Standard_EXPORT BRepMesh_Delaun (BRepMesh::Array1OfVertexOfDelaun& theVertices); Standard_EXPORT BRepMesh_Delaun (IMeshData::Array1OfVertexOfDelaun& theVertices);
//! Creates the triangulation with an existent Mesh data structure. //! Creates the triangulation with an existent Mesh data structure.
Standard_EXPORT BRepMesh_Delaun (const Handle(BRepMesh_DataStructureOfDelaun)& theOldMesh, Standard_EXPORT BRepMesh_Delaun (const Handle(BRepMesh_DataStructureOfDelaun)& theOldMesh,
BRepMesh::Array1OfVertexOfDelaun& theVertices); IMeshData::Array1OfVertexOfDelaun& theVertices);
//! Creates the triangulation with an existant Mesh data structure. //! Creates the triangulation with an existant Mesh data structure.
Standard_EXPORT BRepMesh_Delaun (const Handle(BRepMesh_DataStructureOfDelaun)& theOldMesh, Standard_EXPORT BRepMesh_Delaun (const Handle(BRepMesh_DataStructureOfDelaun)& theOldMesh,
BRepMesh::Array1OfInteger& theVertexIndices); IMeshData::VectorOfInteger& theVertexIndices);
//! Initializes the triangulation with an array of vertices. //! Initializes the triangulation with an array of vertices.
Standard_EXPORT void Init (BRepMesh::Array1OfVertexOfDelaun& theVertices); Standard_EXPORT void Init (IMeshData::Array1OfVertexOfDelaun& theVertices);
//! Removes a vertex from the triangulation. //! Removes a vertex from the triangulation.
Standard_EXPORT void RemoveVertex (const BRepMesh_Vertex& theVertex); Standard_EXPORT void RemoveVertex (const BRepMesh_Vertex& theVertex);
//! Adds some vertices into the triangulation. //! Adds some vertices into the triangulation.
Standard_EXPORT void AddVertices (BRepMesh::Array1OfVertexOfDelaun& theVertices); Standard_EXPORT void AddVertices (IMeshData::VectorOfInteger& theVerticesIndices);
//! Modify mesh to use the edge. //! Modify mesh to use the edge.
//! @return True if done //! @return True if done
@@ -72,19 +72,19 @@ public:
} }
//! Gives the list of frontier edges. //! Gives the list of frontier edges.
inline BRepMesh::HMapOfInteger Frontier() const inline Handle(IMeshData::MapOfInteger) Frontier() const
{ {
return getEdgesByType (BRepMesh_Frontier); return getEdgesByType (BRepMesh_Frontier);
} }
//! Gives the list of internal edges. //! Gives the list of internal edges.
inline BRepMesh::HMapOfInteger InternalEdges() const inline Handle(IMeshData::MapOfInteger) InternalEdges() const
{ {
return getEdgesByType (BRepMesh_Fixed); return getEdgesByType (BRepMesh_Fixed);
} }
//! Gives the list of free edges used only one time //! Gives the list of free edges used only one time
inline BRepMesh::HMapOfInteger FreeEdges() const inline Handle(IMeshData::MapOfInteger) FreeEdges() const
{ {
return getEdgesByType (BRepMesh_Free); return getEdgesByType (BRepMesh_Free);
} }
@@ -131,29 +131,29 @@ private:
InsertBefore InsertBefore
}; };
typedef NCollection_DataMap<Standard_Integer, BRepMesh::MapOfInteger> DataMapOfMap; typedef NCollection_DataMap<Standard_Integer, IMeshData::MapOfInteger> DataMapOfMap;
//! Add boundig box for edge defined by start & end point to //! Add boundig box for edge defined by start & end point to
//! the given vector of bounding boxes for triangulation edges. //! the given vector of bounding boxes for triangulation edges.
void fillBndBox (BRepMesh::SequenceOfBndB2d& theBoxes, void fillBndBox (IMeshData::SequenceOfBndB2d& theBoxes,
const BRepMesh_Vertex& theV1, const BRepMesh_Vertex& theV1,
const BRepMesh_Vertex& theV2); const BRepMesh_Vertex& theV2);
//! Gives the list of edges with type defined by the input parameter. //! Gives the list of edges with type defined by the input parameter.
//! If the given type is BRepMesh_Free returns list of edges //! If the given type is BRepMesh_Free returns list of edges
//! that have number of connected elements less or equal 1. //! that have number of connected elements less or equal 1.
BRepMesh::HMapOfInteger getEdgesByType (const BRepMesh_DegreeOfFreedom theEdgeType) const; Handle(IMeshData::MapOfInteger) getEdgesByType (const BRepMesh_DegreeOfFreedom theEdgeType) const;
//! Create super mesh and run triangulation procedure. //! Create super mesh and run triangulation procedure.
void perform (Bnd_Box2d& theBndBox, void perform (Bnd_Box2d& theBndBox,
BRepMesh::Array1OfInteger& theVertexIndices); IMeshData::VectorOfInteger& theVertexIndices);
//! Build the super mesh. //! Build the super mesh.
void superMesh (const Bnd_Box2d& theBox); void superMesh (const Bnd_Box2d& theBox);
//! Computes the triangulation and adds the vertices, //! Computes the triangulation and adds the vertices,
//! edges and triangles to the Mesh data structure. //! edges and triangles to the Mesh data structure.
void compute (BRepMesh::Array1OfInteger& theVertexIndices); void compute (IMeshData::VectorOfInteger& theVertexIndices);
//! Adjust the mesh on the frontier. //! Adjust the mesh on the frontier.
void frontierAdjust(); void frontierAdjust();
@@ -162,7 +162,7 @@ private:
Standard_Boolean meshLeftPolygonOf( Standard_Boolean meshLeftPolygonOf(
const Standard_Integer theEdgeIndex, const Standard_Integer theEdgeIndex,
const Standard_Boolean isForward, const Standard_Boolean isForward,
BRepMesh::HMapOfInteger theSkipped = NULL); Handle(IMeshData::MapOfInteger) theSkipped = NULL);
//! Find next link starting from the given node and has maximum //! Find next link starting from the given node and has maximum
//! angle respect the given reference link. //! angle respect the given reference link.
@@ -173,12 +173,12 @@ private:
const Standard_Integer& thePivotNode, const Standard_Integer& thePivotNode,
const BRepMesh_Vertex& thePivotVertex, const BRepMesh_Vertex& thePivotVertex,
const gp_Vec2d& theRefLinkDir, const gp_Vec2d& theRefLinkDir,
const BRepMesh::SequenceOfBndB2d& theBoxes, const IMeshData::SequenceOfBndB2d& theBoxes,
const BRepMesh::SequenceOfInteger& thePolygon, const IMeshData::SequenceOfInteger& thePolygon,
const BRepMesh::HMapOfInteger theSkipped, const Handle(IMeshData::MapOfInteger) theSkipped,
const Standard_Boolean& isSkipLeprous, const Standard_Boolean& isSkipLeprous,
BRepMesh::MapOfInteger& theLeprousLinks, IMeshData::MapOfInteger& theLeprousLinks,
BRepMesh::MapOfInteger& theDeadLinks, IMeshData::MapOfInteger& theDeadLinks,
Standard_Integer& theNextPivotNode, Standard_Integer& theNextPivotNode,
gp_Vec2d& theNextLinkDir, gp_Vec2d& theNextLinkDir,
Bnd_B2d& theNextLinkBndBox); Bnd_B2d& theNextLinkBndBox);
@@ -186,8 +186,8 @@ private:
//! Check is the given link intersects the polygon boundaries. //! Check is the given link intersects the polygon boundaries.
//! Returns bounding box for the given link trough the theLinkBndBox parameter. //! Returns bounding box for the given link trough the theLinkBndBox parameter.
Standard_Boolean checkIntersection (const BRepMesh_Edge& theLink, Standard_Boolean checkIntersection (const BRepMesh_Edge& theLink,
const BRepMesh::SequenceOfInteger& thePolygon, const IMeshData::SequenceOfInteger& thePolygon,
const BRepMesh::SequenceOfBndB2d& thePolyBoxes, const IMeshData::SequenceOfBndB2d& thePolyBoxes,
const Standard_Boolean isConsiderEndPointTouch, const Standard_Boolean isConsiderEndPointTouch,
const Standard_Boolean isConsiderPointOnEdge, const Standard_Boolean isConsiderPointOnEdge,
const Standard_Boolean isSkipLastEdge, const Standard_Boolean isSkipLastEdge,
@@ -196,9 +196,9 @@ private:
//! Triangulatiion of a closed polygon described by the list //! Triangulatiion of a closed polygon described by the list
//! of indexes of its edges in the structure. //! of indexes of its edges in the structure.
//! (negative index means reversed edge) //! (negative index means reversed edge)
void meshPolygon (BRepMesh::SequenceOfInteger& thePolygon, void meshPolygon (IMeshData::SequenceOfInteger& thePolygon,
BRepMesh::SequenceOfBndB2d& thePolyBoxes, IMeshData::SequenceOfBndB2d& thePolyBoxes,
BRepMesh::HMapOfInteger theSkipped = NULL); Handle(IMeshData::MapOfInteger) theSkipped = NULL);
//! Decomposes the given closed simple polygon (polygon without glued edges //! Decomposes the given closed simple polygon (polygon without glued edges
//! and loops) on two simpler ones by adding new link at the most thin part //! and loops) on two simpler ones by adding new link at the most thin part
@@ -210,27 +210,27 @@ private:
//! @param thePolygonCut product of decomposition of source polygon (second part of decomposition). //! @param thePolygonCut product of decomposition of source polygon (second part of decomposition).
//! @param thePolyBoxesCut bounding boxes corresponded to resulting polygon's links. //! @param thePolyBoxesCut bounding boxes corresponded to resulting polygon's links.
void decomposeSimplePolygon ( void decomposeSimplePolygon (
BRepMesh::SequenceOfInteger& thePolygon, IMeshData::SequenceOfInteger& thePolygon,
BRepMesh::SequenceOfBndB2d& thePolyBoxes, IMeshData::SequenceOfBndB2d& thePolyBoxes,
BRepMesh::SequenceOfInteger& thePolygonCut, IMeshData::SequenceOfInteger& thePolygonCut,
BRepMesh::SequenceOfBndB2d& thePolyBoxesCut); IMeshData::SequenceOfBndB2d& thePolyBoxesCut);
//! Triangulation of closed polygon containing only three edges. //! Triangulation of closed polygon containing only three edges.
inline Standard_Boolean meshElementaryPolygon (const BRepMesh::SequenceOfInteger& thePolygon); inline Standard_Boolean meshElementaryPolygon (const IMeshData::SequenceOfInteger& thePolygon);
//! Creates the triangles beetween the given node and the given polyline. //! Creates the triangles beetween the given node and the given polyline.
void createTriangles (const Standard_Integer theVertexIndex, void createTriangles (const Standard_Integer theVertexIndex,
BRepMesh::MapOfIntegerInteger& thePoly); IMeshData::MapOfIntegerInteger& thePoly);
//! Add a triangle based on the given oriented edges into mesh //! Add a triangle based on the given oriented edges into mesh
void addTriangle (const Standard_Integer (&theEdgesId)[3], inline void addTriangle (const Standard_Integer (&theEdgesId)[3],
const Standard_Boolean (&theEdgesOri)[3], const Standard_Boolean (&theEdgesOri)[3],
const Standard_Integer (&theNodesId)[3]); const Standard_Integer (&theNodesId)[3]);
//! Deletes the triangle with the given index and adds the free edges into the map. //! Deletes the triangle with the given index and adds the free edges into the map.
//! When an edge is suppressed more than one time it is destroyed. //! When an edge is suppressed more than one time it is destroyed.
void deleteTriangle (const Standard_Integer theIndex, void deleteTriangle (const Standard_Integer theIndex,
BRepMesh::MapOfIntegerInteger& theLoopEdges); IMeshData::MapOfIntegerInteger& theLoopEdges);
//! Returns start and end nodes of the given edge in respect to its orientation. //! Returns start and end nodes of the given edge in respect to its orientation.
void getOrientedNodes (const BRepMesh_Edge& theEdge, void getOrientedNodes (const BRepMesh_Edge& theEdge,
@@ -241,19 +241,19 @@ private:
//! links specified by start and end link indices. //! links specified by start and end link indices.
void processLoop (const Standard_Integer theLinkFrom, void processLoop (const Standard_Integer theLinkFrom,
const Standard_Integer theLinkTo, const Standard_Integer theLinkTo,
const BRepMesh::SequenceOfInteger& thePolygon, const IMeshData::SequenceOfInteger& thePolygon,
const BRepMesh::SequenceOfBndB2d& thePolyBoxes); const IMeshData::SequenceOfBndB2d& thePolyBoxes);
//! Creates new link based on the given nodes and updates the given polygon. //! Creates new link based on the given nodes and updates the given polygon.
Standard_Integer createAndReplacePolygonLink (const Standard_Integer theNodes[], Standard_Integer createAndReplacePolygonLink (const Standard_Integer theNodes[],
const gp_Pnt2d thePnts [], const gp_Pnt2d thePnts [],
const Standard_Integer theRootIndex, const Standard_Integer theRootIndex,
const ReplaceFlag theReplaceFlag, const ReplaceFlag theReplaceFlag,
BRepMesh::SequenceOfInteger& thePolygon, IMeshData::SequenceOfInteger& thePolygon,
BRepMesh::SequenceOfBndB2d& thePolyBoxes); IMeshData::SequenceOfBndB2d& thePolyBoxes);
//! Creates the triangles on new nodes. //! Creates the triangles on new nodes.
void createTrianglesOnNewVertices (BRepMesh::Array1OfInteger& theVertexIndices); void createTrianglesOnNewVertices (IMeshData::VectorOfInteger& theVertexIndices);
//! Cleanup mesh from the free triangles. //! Cleanup mesh from the free triangles.
void cleanupMesh(); void cleanupMesh();
@@ -269,35 +269,35 @@ private:
const Standard_Integer thePrevElementId); const Standard_Integer thePrevElementId);
//! Remove internal triangles from the given polygon. //! Remove internal triangles from the given polygon.
void cleanupPolygon (const BRepMesh::SequenceOfInteger& thePolygon, void cleanupPolygon (const IMeshData::SequenceOfInteger& thePolygon,
const BRepMesh::SequenceOfBndB2d& thePolyBoxes); const IMeshData::SequenceOfBndB2d& thePolyBoxes);
//! Checks is the given vertex lies inside the polygon. //! Checks is the given vertex lies inside the polygon.
Standard_Boolean isVertexInsidePolygon (const Standard_Integer& theVertexId, Standard_Boolean isVertexInsidePolygon (const Standard_Integer& theVertexId,
const BRepMesh::VectorOfInteger& thePolygonVertices) const; const IMeshData::VectorOfInteger& thePolygonVertices) const;
//! Remove all triangles and edges that are placed inside the polygon or crossed it. //! Remove all triangles and edges that are placed inside the polygon or crossed it.
void killTrianglesAroundVertex (const Standard_Integer theZombieNodeId, void killTrianglesAroundVertex (const Standard_Integer theZombieNodeId,
const BRepMesh::VectorOfInteger& thePolyVertices, const IMeshData::VectorOfInteger& thePolyVertices,
const BRepMesh::MapOfInteger& thePolyVerticesFindMap, const IMeshData::MapOfInteger& thePolyVerticesFindMap,
const BRepMesh::SequenceOfInteger& thePolygon, const IMeshData::SequenceOfInteger& thePolygon,
const BRepMesh::SequenceOfBndB2d& thePolyBoxes, const IMeshData::SequenceOfBndB2d& thePolyBoxes,
BRepMesh::MapOfInteger& theSurvivedLinks, IMeshData::MapOfInteger& theSurvivedLinks,
BRepMesh::MapOfIntegerInteger& theLoopEdges); IMeshData::MapOfIntegerInteger& theLoopEdges);
//! Checks is the given link crosses the polygon boundary. //! Checks is the given link crosses the polygon boundary.
//! If yes, kills its triangles and checks neighbor links on boundary intersection. Does nothing elsewhere. //! If yes, kills its triangles and checks neighbor links on boundary intersection. Does nothing elsewhere.
void killTrianglesOnIntersectingLinks (const Standard_Integer& theLinkToCheckId, void killTrianglesOnIntersectingLinks (const Standard_Integer& theLinkToCheckId,
const BRepMesh_Edge& theLinkToCheck, const BRepMesh_Edge& theLinkToCheck,
const Standard_Integer& theEndPoint, const Standard_Integer& theEndPoint,
const BRepMesh::SequenceOfInteger& thePolygon, const IMeshData::SequenceOfInteger& thePolygon,
const BRepMesh::SequenceOfBndB2d& thePolyBoxes, const IMeshData::SequenceOfBndB2d& thePolyBoxes,
BRepMesh::MapOfInteger& theSurvivedLinks, IMeshData::MapOfInteger& theSurvivedLinks,
BRepMesh::MapOfIntegerInteger& theLoopEdges); IMeshData::MapOfIntegerInteger& theLoopEdges);
//! Kill triangles bound to the given link. //! Kill triangles bound to the given link.
void killLinkTriangles (const Standard_Integer& theLinkId, void killLinkTriangles (const Standard_Integer& theLinkId,
BRepMesh::MapOfIntegerInteger& theLoopEdges); IMeshData::MapOfIntegerInteger& theLoopEdges);
//! Calculates distances between the given point and edges of triangle. //! Calculates distances between the given point and edges of triangle.
Standard_Real calculateDist (const gp_XY theVEdges[3], Standard_Real calculateDist (const gp_XY theVEdges[3],
@@ -316,7 +316,7 @@ private:
gp_Pnt2d& theIntPnt) const; gp_Pnt2d& theIntPnt) const;
//! Returns area of the loop of the given polygon defined by indices of its start and end links. //! Returns area of the loop of the given polygon defined by indices of its start and end links.
Standard_Real polyArea (const BRepMesh::SequenceOfInteger& thePolygon, Standard_Real polyArea (const IMeshData::SequenceOfInteger& thePolygon,
const Standard_Integer theStartIndex, const Standard_Integer theStartIndex,
const Standard_Integer theEndIndex) const; const Standard_Integer theEndIndex) const;

2
src/BRepMesh/BRepMesh_Edge.hxx
View File

@@ -76,7 +76,7 @@ public:
} }
//! Alias for IsEqual. //! Alias for IsEqual.
Standard_Boolean operator ==(const BRepMesh_Edge& Other) const inline Standard_Boolean operator ==(const BRepMesh_Edge& Other) const
{ {
return IsEqual(Other); return IsEqual(Other);
} }

115
src/BRepMesh/BRepMesh_EdgeParameterProvider.hxx
View File

@@ -16,44 +16,138 @@
#ifndef _BRepMesh_EdgeParameterProvider_HeaderFile #ifndef _BRepMesh_EdgeParameterProvider_HeaderFile
#define _BRepMesh_EdgeParameterProvider_HeaderFile #define _BRepMesh_EdgeParameterProvider_HeaderFile
#include <IMeshData_Types.hxx>
#include <IMeshData_Edge.hxx>
#include <IMeshData_Face.hxx>
#include <TopoDS.hxx>
#include <Standard.hxx> #include <Standard.hxx>
#include <Standard_DefineAlloc.hxx> #include <Standard_DefineAlloc.hxx>
#include <Extrema_LocateExtPC.hxx> #include <Extrema_LocateExtPC.hxx>
#include <TColStd_HArray1OfReal.hxx> #include <TColStd_HArray1OfReal.hxx>
#include <BRepAdaptor_Curve.hxx> #include <BRepAdaptor_Curve.hxx>
#include <Adaptor3d_CurveOnSurface.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <Geom2dAdaptor_HCurve.hxx>
#include <GeomAdaptor_HSurface.hxx>
class gp_Pnt; class gp_Pnt;
class TopoDS_Edge; class TopoDS_Edge;
class TopoDS_Face; class TopoDS_Face;
#include <TColStd_HArray1OfReal.hxx>
//! Auxiliary class provides correct parameters //! Auxiliary class provides correct parameters
//! on curve regarding SameParameter flag. //! on curve regarding SameParameter flag.
class BRepMesh_EdgeParameterProvider template<class ParametersCollection>
class BRepMesh_EdgeParameterProvider : public Standard_Transient
{ {
public: public:
DEFINE_STANDARD_ALLOC DEFINE_STANDARD_ALLOC
//! Constructor. Initializes empty provider.
BRepMesh_EdgeParameterProvider()
{
}
//! Constructor. //! Constructor.
//! @param theEdge edge which parameters should be processed. //! @param theEdge edge which parameters should be processed.
//! @param theFace face the parametric values are defined for. //! @param theFace face the parametric values are defined for.
//! @param theParameters parameters corresponded to discretization points. //! @param theParameters parameters corresponded to discretization points.
BRepMesh_EdgeParameterProvider( BRepMesh_EdgeParameterProvider(
const TopoDS_Edge& theEdge, const IMeshData::IEdgeHandle& theEdge,
const TopoDS_Face& theFace, const TopAbs_Orientation theOrientation,
const Handle(TColStd_HArray1OfReal)& theParameters); const IMeshData::IFaceHandle& theFace,
const ParametersCollection& theParameters)
{
Init(theEdge, theOrientation, theFace, theParameters);
}
//! Initialized provider by the given data.
void Init (
const IMeshData::IEdgeHandle& theEdge,
const TopAbs_Orientation theOrientation,
const IMeshData::IFaceHandle& theFace,
const ParametersCollection& theParameters)
{
myParameters = theParameters;
myIsSameParam = theEdge->GetSameParam();
myScale = 1.;
// Extract actual parametric values
const TopoDS_Edge aEdge = TopoDS::Edge(theEdge->GetEdge().Oriented(theOrientation));
myCurveAdaptor.Initialize(aEdge, theFace->GetFace());
if (myIsSameParam)
{
return;
}
myFirstParam = myCurveAdaptor.FirstParameter();
const Standard_Real aLastParam = myCurveAdaptor.LastParameter();
myFoundParam = myCurParam = myFirstParam;
// Extract parameters stored in polygon
myOldFirstParam = myParameters->Value(myParameters->Lower());
const Standard_Real aOldLastParam = myParameters->Value(myParameters->Upper());
// Calculate scale factor between actual and stored parameters
if ((myOldFirstParam != myFirstParam || aOldLastParam != aLastParam) &&
myOldFirstParam != aOldLastParam)
{
myScale = (aLastParam - myFirstParam) / (aOldLastParam - myOldFirstParam);
}
myProjector.Initialize(myCurveAdaptor, myCurveAdaptor.FirstParameter(),
myCurveAdaptor.LastParameter(),Precision::PConfusion());
}
//! Returns parameter according to SameParameter flag of the edge. //! Returns parameter according to SameParameter flag of the edge.
//! If SameParameter is TRUE returns value from parameters w/o changes, //! If SameParameter is TRUE returns value from parameters w/o changes,
//! elsewhere scales initial parameter and tries to determine resulting //! elsewhere scales initial parameter and tries to determine resulting
//! value using projection of the corresponded 3D point on PCurve. //! value using projection of the corresponded 3D point on PCurve.
Standard_Real Parameter(const Standard_Integer theIndex, Standard_Real Parameter(const Standard_Integer theIndex,
const gp_Pnt& thePoint3d); const gp_Pnt& thePoint3d) const
{
if (myIsSameParam)
{
return myParameters->Value(theIndex);
}
// Use scaled
const Standard_Real aParam = myParameters->Value(theIndex);
const Standard_Real aPrevParam = myCurParam;
myCurParam = myFirstParam + myScale * (aParam - myOldFirstParam);
const Standard_Real aPrevFoundParam = myFoundParam;
myFoundParam += (myCurParam - aPrevParam);
myProjector.Perform(thePoint3d, myFoundParam);
if (myProjector.IsDone())
{
const Standard_Real aFoundParam = myProjector.Point().Parameter();
if ((aPrevFoundParam < myFoundParam && aPrevFoundParam < aFoundParam) ||
(aPrevFoundParam > myFoundParam && aPrevFoundParam > aFoundParam))
{
// Rude protection against case when amplified parameter goes before
// previous one due to period or other reason occurred in projector.
// Using parameter returned by projector as is can produce self-intersections.
myFoundParam = aFoundParam;
}
}
return myFoundParam;
}
//! Returns pcurve used to compute parameters.
const Handle(Adaptor2d_HCurve2d)& GetPCurve() const
{
return myCurveAdaptor.CurveOnSurface().GetCurve();
}
private: private:
Handle(TColStd_HArray1OfReal) myParameters; ParametersCollection myParameters;
Standard_Boolean myIsSameParam; Standard_Boolean myIsSameParam;
Standard_Real myFirstParam; Standard_Real myFirstParam;
@@ -61,11 +155,12 @@ private:
Standard_Real myOldFirstParam; Standard_Real myOldFirstParam;
Standard_Real myScale; Standard_Real myScale;
Standard_Real myCurParam; mutable Standard_Real myCurParam;
Standard_Real myFoundParam; mutable Standard_Real myFoundParam;
BRepAdaptor_Curve myCurveAdaptor; BRepAdaptor_Curve myCurveAdaptor;
Extrema_LocateExtPC myProjector;
mutable Extrema_LocateExtPC myProjector;
}; };
#endif #endif

68
src/BRepMesh/BRepMesh_EdgeTessellationExtractor.cxx
View File

@@ -1,6 +1,6 @@
// Created on: 2014-08-13 // Created on: 2016-04-19
// Copyright (c) 2016 OPEN CASCADE SAS
// Created by: Oleg AGASHIN // Created by: Oleg AGASHIN
// Copyright (c) 2011-2014 OPEN CASCADE SAS
// //
// This file is part of Open CASCADE Technology software library. // This file is part of Open CASCADE Technology software library.
// //
@@ -14,48 +14,60 @@
// commercial license or contractual agreement. // commercial license or contractual agreement.
#include <BRepMesh_EdgeTessellationExtractor.hxx> #include <BRepMesh_EdgeTessellationExtractor.hxx>
#include <Geom2dAdaptor_HCurve.hxx>
#include <Poly_PolygonOnTriangulation.hxx>
#include <Poly_Triangulation.hxx>
#include <BRepMesh_ShapeTool.hxx> #include <BRepMesh_ShapeTool.hxx>
#include <gp_Pnt.hxx>
#include <BRep_Tool.hxx>
IMPLEMENT_STANDARD_RTTIEXT(BRepMesh_EdgeTessellationExtractor,BRepMesh_IEdgeTool) #include <IMeshData_Face.hxx>
#include <IMeshData_Edge.hxx>
//======================================================================= //=======================================================================
//function : Constructor //function : Constructor
//purpose : //purpose :
//======================================================================= //=======================================================================
BRepMesh_EdgeTessellationExtractor::BRepMesh_EdgeTessellationExtractor( BRepMesh_EdgeTessellationExtractor::BRepMesh_EdgeTessellationExtractor (
const TopoDS_Edge& theEdge, const IMeshData::IEdgeHandle& theEdge,
const Handle(Geom2dAdaptor_HCurve)& thePCurve, const IMeshData::IFaceHandle& theFace)
const TopoDS_Face& theFace,
const Handle(Poly_Triangulation)& theTriangulation,
const Handle(Poly_PolygonOnTriangulation)& thePolygon,
const TopLoc_Location& theLocation)
: myProvider(theEdge, theFace, thePolygon->Parameters()),
myPCurve(thePCurve),
myNodes(theTriangulation->Nodes()),
myIndices(thePolygon->Nodes()),
myLoc(theLocation)
{ {
Handle (Poly_Triangulation) aTriangulation =
BRep_Tool::Triangulation (theFace->GetFace(), myLoc);
Handle (Poly_PolygonOnTriangulation) aPolygon =
BRep_Tool::PolygonOnTriangulation (theEdge->GetEdge(), aTriangulation, myLoc);
myNodes = &aTriangulation->Nodes ();
myIndices = &aPolygon->Nodes ();
myProvider.Init (theEdge, TopAbs_FORWARD, theFace, aPolygon->Parameters ());
}
//=======================================================================
//function : Constructor
//purpose :
//=======================================================================
BRepMesh_EdgeTessellationExtractor::~BRepMesh_EdgeTessellationExtractor ()
{
}
//=======================================================================
//function : NbPoints
//purpose :
//=======================================================================
Standard_Integer BRepMesh_EdgeTessellationExtractor::PointsNb () const
{
return myIndices->Size ();
} }
//======================================================================= //=======================================================================
//function : Value //function : Value
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Boolean BRepMesh_EdgeTessellationExtractor::Value( Standard_Boolean BRepMesh_EdgeTessellationExtractor::Value (
const Standard_Integer theIndex, const Standard_Integer theIndex,
Standard_Real& theParameter,
gp_Pnt& thePoint, gp_Pnt& thePoint,
gp_Pnt2d& theUV) Standard_Real& theParameter) const
{ {
const gp_Pnt& theRefPnt = myNodes(myIndices(theIndex)); const gp_Pnt& theRefPnt = (*myNodes) ((*myIndices) (theIndex));
thePoint = BRepMesh_ShapeTool::UseLocation(theRefPnt, myLoc); thePoint = BRepMesh_ShapeTool::UseLocation (theRefPnt, myLoc);
theParameter = myProvider.Parameter(theIndex, thePoint);
theUV = myPCurve->Value(theParameter);
theParameter = myProvider.Parameter (theIndex, thePoint);
return Standard_True; return Standard_True;
} }

66
src/BRepMesh/BRepMesh_EdgeTessellationExtractor.hxx
View File

@@ -1,6 +1,6 @@
// Created on: 2014-08-13 // Created on: 2016-04-19
// Copyright (c) 2016 OPEN CASCADE SAS
// Created by: Oleg AGASHIN // Created by: Oleg AGASHIN
// Copyright (c) 2011-2014 OPEN CASCADE SAS
// //
// This file is part of Open CASCADE Technology software library. // This file is part of Open CASCADE Technology software library.
// //
@@ -16,72 +16,48 @@
#ifndef _BRepMesh_EdgeTessellationExtractor_HeaderFile #ifndef _BRepMesh_EdgeTessellationExtractor_HeaderFile
#define _BRepMesh_EdgeTessellationExtractor_HeaderFile #define _BRepMesh_EdgeTessellationExtractor_HeaderFile
#include <Standard.hxx> #include <IMeshTools_CurveTessellator.hxx>
#include <Standard_DefineAlloc.hxx> #include <IMeshData_Types.hxx>
#include <BRepMesh_IEdgeTool.hxx>
#include <BRepMesh_EdgeParameterProvider.hxx> #include <BRepMesh_EdgeParameterProvider.hxx>
#include <TopLoc_Location.hxx>
#include <TColgp_Array1OfPnt.hxx> #include <TColgp_Array1OfPnt.hxx>
#include <TColStd_Array1OfInteger.hxx> #include <TColStd_Array1OfInteger.hxx>
#include <TopLoc_Location.hxx>
class Poly_Triangulation;
class Poly_PolygonOnTriangulation;
class TopoDS_Edge;
class TopoDS_Face;
class Geom2dAdaptor_HCurve;
//! Auxiliary class implements functionality retrieving tessellated //! Auxiliary class implements functionality retrieving tessellated
//! representation of an edge stored in polygon. //! representation of an edge stored in polygon.
class BRepMesh_EdgeTessellationExtractor : public BRepMesh_IEdgeTool class BRepMesh_EdgeTessellationExtractor : public IMeshTools_CurveTessellator
{ {
public: public:
//! Constructor. //! Constructor.
//! Initializes extractor. Standard_EXPORT BRepMesh_EdgeTessellationExtractor (
BRepMesh_EdgeTessellationExtractor( const IMeshData::IEdgeHandle& theEdge,
const TopoDS_Edge& theEdge, const IMeshData::IFaceHandle& theFace);
const Handle(Geom2dAdaptor_HCurve)& thePCurve,
const TopoDS_Face& theFace,
const Handle(Poly_Triangulation)& theTriangulation,
const Handle(Poly_PolygonOnTriangulation)& thePolygon,
const TopLoc_Location& theLocation);
//! Returns number of dicretization points. //! Destructor.
virtual Standard_Integer NbPoints() const Standard_OVERRIDE Standard_EXPORT virtual ~BRepMesh_EdgeTessellationExtractor ();
{
return myIndices.Length(); //! Returns number of tessellation points.
} Standard_EXPORT virtual Standard_Integer PointsNb () const Standard_OVERRIDE;
//! Returns parameters of solution with the given index. //! Returns parameters of solution with the given index.
//! @param theIndex index of tessellation point. //! @param theIndex index of tessellation point.
//! @param theParameter parameters on PCurve corresponded to the solution. //! @param theParameter parameters on PCurve corresponded to the solution.
//! @param thePoint tessellation point. //! @param thePoint tessellation point.
//! @param theUV coordinates of tessellation point in parametric space of face.
//! @return True in case of valid result, false elewhere. //! @return True in case of valid result, false elewhere.
virtual Standard_Boolean Value( Standard_EXPORT virtual Standard_Boolean Value (
const Standard_Integer theIndex, const Standard_Integer theIndex,
Standard_Real& theParameter,
gp_Pnt& thePoint, gp_Pnt& thePoint,
gp_Pnt2d& theUV) Standard_OVERRIDE; Standard_Real& theParameter) const Standard_OVERRIDE;
DEFINE_STANDARD_RTTIEXT(BRepMesh_EdgeTessellationExtractor,BRepMesh_IEdgeTool) DEFINE_STANDARD_RTTI_INLINE(BRepMesh_EdgeTessellationExtractor, IMeshTools_CurveTessellator)
private: private:
//! Assignment operator. BRepMesh_EdgeParameterProvider<Handle(TColStd_HArray1OfReal)> myProvider;
void operator =(const BRepMesh_EdgeTessellationExtractor& /*theOther*/) const TColgp_Array1OfPnt* myNodes;
{ const TColStd_Array1OfInteger* myIndices;
} TopLoc_Location myLoc;
private:
BRepMesh_EdgeParameterProvider myProvider;
Handle(Geom2dAdaptor_HCurve) myPCurve;
const TColgp_Array1OfPnt& myNodes;
const TColStd_Array1OfInteger& myIndices;
const TopLoc_Location myLoc;
}; };
DEFINE_STANDARD_HANDLE(BRepMesh_EdgeTessellationExtractor, BRepMesh_IEdgeTool)
#endif #endif

17
src/BRepMesh/BRepMesh_GeomTool.cxx
View File

@@ -76,8 +76,10 @@ BRepMesh_GeomTool::BRepMesh_GeomTool(
//======================================================================= //=======================================================================
Standard_Boolean BRepMesh_GeomTool::Value( Standard_Boolean BRepMesh_GeomTool::Value(
const Standard_Integer theIndex, const Standard_Integer theIndex,
const Handle(BRepAdaptor_HSurface)& theSurface,
Standard_Real& theParam, Standard_Real& theParam,
gp_Pnt& thePoint) const gp_Pnt& thePoint,
gp_Pnt2d& theUV) const
{ {
if (theIndex < 1 || theIndex > NbPoints()) if (theIndex < 1 || theIndex > NbPoints())
return Standard_False; return Standard_False;
@@ -88,6 +90,14 @@ Standard_Boolean BRepMesh_GeomTool::Value(
thePoint = myDiscretTool.Value(theIndex); thePoint = myDiscretTool.Value(theIndex);
theParam = myDiscretTool.Parameter(theIndex); theParam = myDiscretTool.Parameter(theIndex);
const TopoDS_Face& aFace = ((BRepAdaptor_Surface*)&(theSurface->Surface()))->Face();
Standard_Real aFirst, aLast;
Handle(Geom2d_Curve) aCurve =
BRep_Tool::CurveOnSurface(*myEdge, aFace, aFirst, aLast);
aCurve->D0(theParam, theUV);
return Standard_True; return Standard_True;
} }
@@ -95,7 +105,8 @@ Standard_Boolean BRepMesh_GeomTool::Value(
//function : Value //function : Value
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Boolean BRepMesh_GeomTool::Value(const Standard_Integer theIndex, Standard_Boolean BRepMesh_GeomTool::Value(
const Standard_Integer theIndex,
const Standard_Real theIsoParam, const Standard_Real theIsoParam,
Standard_Real& theParam, Standard_Real& theParam,
gp_Pnt& thePoint, gp_Pnt& thePoint,
@@ -286,7 +297,7 @@ BRepMesh_GeomTool::IntFlag BRepMesh_GeomTool::IntSegSeg(
const Standard_Real aEndPrec = 1 - aPrec; const Standard_Real aEndPrec = 1 - aPrec;
for (Standard_Integer i = 0; i < 2; ++i) for (Standard_Integer i = 0; i < 2; ++i)
{ {
if( aParam[i] < aPrec || aParam[i] > aEndPrec ) if(aParam[i] < aPrec || aParam[i] > aEndPrec )
return BRepMesh_GeomTool::NoIntersection; return BRepMesh_GeomTool::NoIntersection;
} }

28
src/BRepMesh/BRepMesh_GeomTool.hxx
View File

@@ -60,7 +60,8 @@ public:
//! @param theLinDeflection linear deflection. //! @param theLinDeflection linear deflection.
//! @param theAngDeflection angular deflection. //! @param theAngDeflection angular deflection.
//! @param theMinPointsNb minimum nuber of points to be produced. //! @param theMinPointsNb minimum nuber of points to be produced.
Standard_EXPORT BRepMesh_GeomTool(const BRepAdaptor_Curve& theCurve, Standard_EXPORT BRepMesh_GeomTool(
const BRepAdaptor_Curve& theCurve,
const Standard_Real theFirstParam, const Standard_Real theFirstParam,
const Standard_Real theLastParam, const Standard_Real theLastParam,
const Standard_Real theLinDeflection, const Standard_Real theLinDeflection,
@@ -79,7 +80,8 @@ public:
//! @param theLinDeflection linear deflection. //! @param theLinDeflection linear deflection.
//! @param theAngDeflection angular deflection. //! @param theAngDeflection angular deflection.
//! @param theMinPointsNb minimum nuber of points to be produced. //! @param theMinPointsNb minimum nuber of points to be produced.
Standard_EXPORT BRepMesh_GeomTool(const Handle(BRepAdaptor_HSurface)& theSurface, Standard_EXPORT BRepMesh_GeomTool(
const Handle(BRepAdaptor_HSurface)& theSurface,
const GeomAbs_IsoType theIsoType, const GeomAbs_IsoType theIsoType,
const Standard_Real theParamIso, const Standard_Real theParamIso,
const Standard_Real theFirstParam, const Standard_Real theFirstParam,
@@ -124,12 +126,16 @@ public:
//! Gets parameters of discretization point with the given index. //! Gets parameters of discretization point with the given index.
//! @param theIndex index of discretization point. //! @param theIndex index of discretization point.
//! @param theSurface surface the curve is lying onto.
//! @param theParam[out] parameter of the point on the curve. //! @param theParam[out] parameter of the point on the curve.
//! @param thePoint[out] discretization point. //! @param thePoint[out] discretization point.
//! @param theUV[out] discretization point in parametric space of the surface.
//! @return TRUE on success, FALSE elsewhere. //! @return TRUE on success, FALSE elsewhere.
Standard_EXPORT Standard_Boolean Value(const Standard_Integer theIndex, Standard_EXPORT Standard_Boolean Value(const Standard_Integer theIndex,
const Handle(BRepAdaptor_HSurface)& theSurface,
Standard_Real& theParam, Standard_Real& theParam,
gp_Pnt& thePoint) const; gp_Pnt& thePoint,
gp_Pnt2d& theUV) const;
public: //! @name static API public: //! @name static API
@@ -188,6 +194,22 @@ public: //! @name static API
const Standard_Boolean isConsiderPointOnSegment, const Standard_Boolean isConsiderPointOnSegment,
gp_Pnt2d& theIntPnt); gp_Pnt2d& theIntPnt);
//! Compute deflection of the given segment.
Standard_EXPORT static Standard_Real SquareDeflectionOfSegment(
const gp_Pnt& theFirstPoint,
const gp_Pnt& theLastPoint,
const gp_Pnt& theMidPoint)
{
// 23.03.2010 skl for OCC21645 - change precision for comparison
if (theFirstPoint.SquareDistance(theLastPoint) > Precision::SquareConfusion())
{
gp_Lin aLin(theFirstPoint, gp_Dir(gp_Vec(theFirstPoint, theLastPoint)));
return aLin.SquareDistance(theMidPoint);
}
return theFirstPoint.SquareDistance(theMidPoint);
}
private: private:
//! Classifies the point in case of coincidence of two vectors. //! Classifies the point in case of coincidence of two vectors.

499
src/BRepMesh/BRepMesh_IncrementalMesh.cxx
View File

@@ -15,46 +15,12 @@
// commercial license or contractual agreement. // commercial license or contractual agreement.
#include <BRepMesh_IncrementalMesh.hxx> #include <BRepMesh_IncrementalMesh.hxx>
#include <BRepMesh_Context.hxx>
#include <OSD_Parallel.hxx> #include <BRepMesh_MeshBuilder.hxx>
#include <Precision.hxx>
#include <Standard_ErrorHandler.hxx>
#include <BRepMesh_ShapeTool.hxx>
#include <BRepMesh_Edge.hxx>
#include <BRepMesh_PluginMacro.hxx> #include <BRepMesh_PluginMacro.hxx>
#include <IMeshData_Status.hxx>
#include <Bnd_Box.hxx> #include <IMeshData_Face.hxx>
#include <BRep_Builder.hxx> #include <IMeshData_Wire.hxx>
#include <BRep_Tool.hxx>
#include <BRepTools.hxx>
#include <BRepLib.hxx>
#include <BRepBndLib.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <Poly_Triangulation.hxx>
#include <Poly_Polygon3D.hxx>
#include <Poly_PolygonOnTriangulation.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Shape.hxx>
#include <TopAbs.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <TColStd_MapOfTransient.hxx>
#include <TopTools_HArray1OfShape.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <GCPnts_TangentialDeflection.hxx>
IMPLEMENT_STANDARD_RTTIEXT(BRepMesh_IncrementalMesh,BRepMesh_DiscretRoot)
namespace namespace
{ {
@@ -63,15 +29,13 @@ namespace
static Standard_Boolean IS_IN_PARALLEL = Standard_False; static Standard_Boolean IS_IN_PARALLEL = Standard_False;
} }
//======================================================================= //=======================================================================
//function : Default constructor //function : Default constructor
//purpose : //purpose :
//======================================================================= //=======================================================================
BRepMesh_IncrementalMesh::BRepMesh_IncrementalMesh() BRepMesh_IncrementalMesh::BRepMesh_IncrementalMesh()
: myMaxShapeSize(0.), : myModified(Standard_False),
myModified(Standard_False), myStatus(IMeshData_NoError)
myStatus(0)
{ {
} }
@@ -83,17 +47,14 @@ BRepMesh_IncrementalMesh::BRepMesh_IncrementalMesh( const TopoDS_Shape& theSh
const Standard_Real theLinDeflection, const Standard_Real theLinDeflection,
const Standard_Boolean isRelative, const Standard_Boolean isRelative,
const Standard_Real theAngDeflection, const Standard_Real theAngDeflection,
const Standard_Boolean isInParallel, const Standard_Boolean isInParallel)
const Standard_Boolean adaptiveMin) : myModified(Standard_False),
: myMaxShapeSize(0.), myStatus(IMeshData_NoError)
myModified(Standard_False),
myStatus(0)
{ {
myParameters.Deflection = theLinDeflection; myParameters.Deflection = theLinDeflection;
myParameters.Relative = isRelative; myParameters.Relative = isRelative;
myParameters.Angle = theAngDeflection; myParameters.Angle = theAngDeflection;
myParameters.InParallel = isInParallel; myParameters.InParallel = isInParallel;
myParameters.AdaptiveMin = adaptiveMin;
myShape = theShape; myShape = theShape;
Perform(); Perform();
@@ -103,12 +64,12 @@ BRepMesh_IncrementalMesh::BRepMesh_IncrementalMesh( const TopoDS_Shape& theSh
//function : Constructor //function : Constructor
//purpose : //purpose :
//======================================================================= //=======================================================================
BRepMesh_IncrementalMesh::BRepMesh_IncrementalMesh(const TopoDS_Shape& theShape, BRepMesh_IncrementalMesh::BRepMesh_IncrementalMesh(
const BRepMesh_FastDiscret::Parameters& theParameters) const TopoDS_Shape& theShape,
const IMeshTools_Parameters& theParameters)
: myParameters(theParameters) : myParameters(theParameters)
{ {
myShape = theShape; myShape = theShape;
Perform(); Perform();
} }
@@ -120,436 +81,32 @@ BRepMesh_IncrementalMesh::~BRepMesh_IncrementalMesh()
{ {
} }
//=======================================================================
//function : clear
//purpose :
//=======================================================================
void BRepMesh_IncrementalMesh::clear()
{
// the allocator will be alive while the structures are alive
Handle(NCollection_BaseAllocator) anAlloc =
new NCollection_IncAllocator(BRepMesh::MEMORY_BLOCK_SIZE_HUGE);
myEdges.Clear(anAlloc);
myEdgeDeflection.Clear(anAlloc);
myFaces.Clear();
myMesh.Nullify();
}
//=======================================================================
//function : init
//purpose :
//=======================================================================
void BRepMesh_IncrementalMesh::init()
{
myStatus = 0;
myModified = Standard_False;
setDone();
clear();
collectFaces();
Bnd_Box aBox;
if ( myParameters.Relative )
{
BRepBndLib::Add(myShape, aBox, Standard_False);
if (aBox.IsVoid())
{
// Nothing to mesh.
return;
}
BRepMesh_ShapeTool::BoxMaxDimension(aBox, myMaxShapeSize);
}
myMesh = new BRepMesh_FastDiscret (aBox, myParameters);
myMesh->InitSharedFaces(myShape);
}
//=======================================================================
//function : collectFaces
//purpose :
//=======================================================================
void BRepMesh_IncrementalMesh::collectFaces()
{
Handle(NCollection_IncAllocator) anAlloc = new NCollection_IncAllocator;
TopTools_ListOfShape aFaceList(anAlloc);
BRepLib::ReverseSortFaces(myShape, aFaceList);
TColStd_MapOfTransient aTFaceMap(1, anAlloc);
// make array of faces suitable for processing (excluding faces without surface)
TopLoc_Location aDummyLoc;
TopTools_ListIteratorOfListOfShape aFaceIter(aFaceList);
for (; aFaceIter.More(); aFaceIter.Next())
{
const TopoDS_Face& aFace = TopoDS::Face(aFaceIter.Value());
const Handle(TopoDS_TShape)& aTFace = aFace.TShape();
if (!aTFaceMap.Add (aTFace))
continue; // already processed
const Handle(Geom_Surface)& aSurf = BRep_Tool::Surface(aFace, aDummyLoc);
if (aSurf.IsNull())
continue;
myFaces.Append(aFace);
}
}
//======================================================================= //=======================================================================
//function : Perform //function : Perform
//purpose : //purpose :
//======================================================================= //=======================================================================
void BRepMesh_IncrementalMesh::Perform() void BRepMesh_IncrementalMesh::Perform()
{ {
init(); Handle(BRepMesh_Context) aContext = new BRepMesh_Context;
aContext->SetShape(Shape());
aContext->ChangeParameters() = myParameters;
aContext->ChangeParameters().CleanModel = Standard_False;
if (myMesh.IsNull()) BRepMesh_MeshBuilder aIncMesh(aContext);
return; aIncMesh.Perform();
update(); myStatus = IMeshData_NoError;
} const Handle(IMeshData_Model)& aModel = aContext->GetModel();
for (Standard_Integer aFaceIt = 0; aFaceIt < aModel->FacesNb(); ++aFaceIt)
//=======================================================================
//function : update()
//purpose :
//=======================================================================
void BRepMesh_IncrementalMesh::update()
{
// Update edges data
TopExp_Explorer aExplorer(myShape, TopAbs_EDGE);
for (; aExplorer.More(); aExplorer.Next())
{ {
const TopoDS_Edge& aEdge = TopoDS::Edge(aExplorer.Current()); const IMeshData::IFaceHandle& aDFace = aModel->GetFace(aFaceIt);
if(!BRep_Tool::IsGeometric(aEdge)) myStatus |= aDFace->GetStatusMask();
continue;
update(aEdge); for (Standard_Integer aWireIt = 0; aWireIt < aDFace->WiresNb(); ++aWireIt)
{
const IMeshData::IWireHandle& aDWire = aDFace->GetWire(aWireIt);
myStatus |= aDWire->GetStatusMask();
} }
// Update faces data
NCollection_Vector<TopoDS_Face>::Iterator aFaceIt(myFaces);
for (; aFaceIt.More(); aFaceIt.Next())
update(aFaceIt.Value());
// Mesh faces
OSD_Parallel::ForEach(myFaces.begin(), myFaces.end(), *myMesh, !myParameters.InParallel);
commit();
clear();
}
//=======================================================================
//function : discretizeFreeEdges
//purpose :
//=======================================================================
void BRepMesh_IncrementalMesh::discretizeFreeEdges()
{
TopExp_Explorer aExplorer(myShape ,TopAbs_EDGE, TopAbs_FACE);
for (; aExplorer.More(); aExplorer.Next())
{
const TopoDS_Edge& aEdge = TopoDS::Edge(aExplorer.Current());
if(!BRep_Tool::IsGeometric(aEdge))
continue;
TopLoc_Location aLoc;
Standard_Real aEdgeDeflection = edgeDeflection(aEdge);
Handle(Poly_Polygon3D) aPoly3D = BRep_Tool::Polygon3D(aEdge, aLoc);
if (!aPoly3D.IsNull() && aPoly3D->Deflection() < 1.1 * aEdgeDeflection)
continue;
BRepAdaptor_Curve aCurve(aEdge);
GCPnts_TangentialDeflection aDiscret(aCurve, aCurve.FirstParameter(),
aCurve.LastParameter(), myParameters.Angle, aEdgeDeflection, 2,
Precision::PConfusion(), myParameters.MinSize);
Standard_Integer aNodesNb = aDiscret.NbPoints();
TColgp_Array1OfPnt aNodes (1, aNodesNb);
TColStd_Array1OfReal aUVNodes(1, aNodesNb);
for (Standard_Integer i = 1; i <= aNodesNb; ++i)
{
aNodes (i) = aDiscret.Value(i);
aUVNodes(i) = aDiscret.Parameter(i);
}
aPoly3D = new Poly_Polygon3D(aNodes, aUVNodes);
aPoly3D->Deflection(myParameters.Deflection);
BRep_Builder aBuilder;
aBuilder.UpdateEdge(aEdge, aPoly3D);
}
}
//=======================================================================
//function : edgeDeflection
//purpose :
//=======================================================================
Standard_Real BRepMesh_IncrementalMesh::edgeDeflection(
const TopoDS_Edge& theEdge)
{
const Standard_Real* pDef = myEdgeDeflection.Seek(theEdge);
if (pDef)
return *pDef;
Standard_Real aEdgeDeflection;
if ( myParameters.Relative )
{
Standard_Real aScale;
aEdgeDeflection = BRepMesh_ShapeTool::RelativeEdgeDeflection(theEdge,
myParameters.Deflection, myMaxShapeSize, aScale);
}
else
aEdgeDeflection = myParameters.Deflection;
myEdgeDeflection.Bind(theEdge, aEdgeDeflection);
return aEdgeDeflection;
}
//=======================================================================
//function : faceDeflection
//purpose :
//=======================================================================
Standard_Real BRepMesh_IncrementalMesh::faceDeflection(
const TopoDS_Face& theFace)
{
if ( !myParameters.Relative )
return myParameters.Deflection;
Standard_Integer aEdgesNb = 0;
Standard_Real aFaceDeflection = 0.;
TopExp_Explorer aEdgeIt(theFace, TopAbs_EDGE);
for (; aEdgeIt.More(); aEdgeIt.Next(), ++aEdgesNb)
{
const TopoDS_Edge& aEdge = TopoDS::Edge(aEdgeIt.Current());
aFaceDeflection += edgeDeflection(aEdge);
}
return (aEdgesNb == 0) ? myParameters.Deflection : (aFaceDeflection / aEdgesNb);
}
//=======================================================================
//function : update(edge)
//purpose :
//=======================================================================
void BRepMesh_IncrementalMesh::update(const TopoDS_Edge& theEdge)
{
if (!myEdges.IsBound(theEdge))
myEdges.Bind(theEdge, BRepMesh::DMapOfTriangulationBool(3, myEdges.Allocator()));
Standard_Real aEdgeDeflection = edgeDeflection(theEdge);
// Check that triangulation relies to face of the given shape.
const TopTools_IndexedDataMapOfShapeListOfShape& aMapOfSharedFaces =
myMesh->SharedFaces();
const TopTools_ListOfShape& aSharedFaces =
aMapOfSharedFaces.FindFromKey(theEdge);
TopTools_ListIteratorOfListOfShape aSharedFaceIt(aSharedFaces);
for (; aSharedFaceIt.More(); aSharedFaceIt.Next())
{
TopLoc_Location aLoc;
const TopoDS_Face& aFace = TopoDS::Face(aSharedFaceIt.Value());
const Handle(Poly_Triangulation)& aFaceTriangulation =
BRep_Tool::Triangulation(aFace, aLoc);
if (aFaceTriangulation.IsNull())
continue;
Standard_Boolean isConsistent = Standard_False;
const Handle(Poly_PolygonOnTriangulation)& aPolygon =
BRep_Tool::PolygonOnTriangulation(theEdge, aFaceTriangulation, aLoc);
if (!aPolygon.IsNull())
{
isConsistent = aPolygon->Deflection() < 1.1 * aEdgeDeflection &&
aPolygon->HasParameters();
if (!isConsistent)
{
myModified = Standard_True;
BRepMesh_ShapeTool::NullifyEdge(theEdge, aFaceTriangulation, aLoc);
}
}
myEdges(theEdge).Bind(aFaceTriangulation, isConsistent);
}
}
//=======================================================================
//function : isToBeMeshed
//purpose :
//=======================================================================
Standard_Boolean BRepMesh_IncrementalMesh::toBeMeshed(
const TopoDS_Face& theFace,
const Standard_Boolean isWithCheck)
{
TopLoc_Location aLoc;
const Handle(Poly_Triangulation)& aTriangulation =
BRep_Tool::Triangulation(theFace, aLoc);
if (aTriangulation.IsNull())
return Standard_True;
if (isWithCheck)
{
Standard_Real aFaceDeflection = faceDeflection(theFace);
if (aTriangulation->Deflection() < 1.1 * aFaceDeflection)
{
Standard_Boolean isEdgesConsistent = Standard_True;
TopExp_Explorer aEdgeIt(theFace, TopAbs_EDGE);
for (; aEdgeIt.More() && isEdgesConsistent; aEdgeIt.Next())
{
const TopoDS_Edge& aEdge = TopoDS::Edge(aEdgeIt.Current());
if (!myEdges.IsBound(aEdge))
continue;
BRepMesh::DMapOfTriangulationBool& aTriMap = myEdges(aEdge);
isEdgesConsistent &= aTriMap.IsBound(aTriangulation) &&
aTriMap(aTriangulation);
}
if (isEdgesConsistent)
{
// #25080: check that indices of links forming triangles are in range.
Standard_Boolean isTriangulationConsistent = Standard_True;
const Standard_Integer aNodesNb = aTriangulation->NbNodes();
const Poly_Array1OfTriangle& aTriangles = aTriangulation->Triangles();
Standard_Integer i = aTriangles.Lower();
for (; i <= aTriangles.Upper() && isTriangulationConsistent; ++i)
{
const Poly_Triangle& aTriangle = aTriangles(i);
Standard_Integer n[3];
aTriangle.Get(n[0], n[1], n[2]);
for (Standard_Integer j = 0; j < 3 && isTriangulationConsistent; ++j)
isTriangulationConsistent = (n[j] >= 1 && n[j] <= aNodesNb);
}
if (isTriangulationConsistent)
return Standard_False;
}
}
}
// Nullify edges
TopExp_Explorer aEdgeIt(theFace, TopAbs_EDGE);
for (; aEdgeIt.More(); aEdgeIt.Next())
{
const TopoDS_Edge& aEdge = TopoDS::Edge(aEdgeIt.Current());
BRepMesh_ShapeTool::NullifyEdge(aEdge, aTriangulation, aLoc);
}
BRepMesh_ShapeTool::NullifyFace(theFace);
return Standard_True;
}
//=======================================================================
//function : update(face)
//purpose :
//=======================================================================
void BRepMesh_IncrementalMesh::update(const TopoDS_Face& theFace)
{
if (!toBeMeshed(theFace, Standard_True))
return;
myModified = Standard_True;
Standard_Integer aStatus = myMesh->Add(theFace);
myStatus |= aStatus;
if (aStatus != BRepMesh_ReMesh)
return;
BRepMesh::MapOfShape aUsedFaces;
aUsedFaces.Add(theFace);
const TopTools_IndexedDataMapOfShapeListOfShape& aMapOfSharedFaces =
myMesh->SharedFaces();
TopExp_Explorer aEdgeIt(theFace, TopAbs_EDGE);
for (; aEdgeIt.More(); aEdgeIt.Next())
{
const TopoDS_Edge& aEdge = TopoDS::Edge(aEdgeIt.Current());
if (aMapOfSharedFaces.FindIndex(aEdge) == 0)
continue;
const TopTools_ListOfShape& aSharedFaces = aMapOfSharedFaces.FindFromKey(aEdge);
TopTools_ListIteratorOfListOfShape aSharedFaceIt(aSharedFaces);
for (; aSharedFaceIt.More(); aSharedFaceIt.Next())
{
const TopoDS_Face& aFace = TopoDS::Face(aSharedFaceIt.Value());
if (aUsedFaces.Contains(aFace))
continue;
aUsedFaces.Add(aFace);
toBeMeshed(aFace, Standard_False);
myStatus |= myMesh->Add(aFace);
}
}
}
//=======================================================================
//function : commit
//purpose :
//=======================================================================
void BRepMesh_IncrementalMesh::commit()
{
NCollection_Vector<TopoDS_Face>::Iterator aFaceIt(myFaces);
for (; aFaceIt.More(); aFaceIt.Next())
commitEdges(aFaceIt.Value());
discretizeFreeEdges();
}
//=======================================================================
//function : commitEdges
//purpose :
//=======================================================================
void BRepMesh_IncrementalMesh::commitEdges(const TopoDS_Face& theFace)
{
TopoDS_Face aFace = theFace;
aFace.Orientation(TopAbs_FORWARD);
Handle(BRepMesh_FaceAttribute) aFaceAttribute;
if (!myMesh->GetFaceAttribute(aFace, aFaceAttribute))
return;
if (!aFaceAttribute->IsValid())
{
myStatus |= aFaceAttribute->GetStatus();
return;
}
TopLoc_Location aLoc;
Handle(Poly_Triangulation) aTriangulation = BRep_Tool::Triangulation(aFace, aLoc);
if (aTriangulation.IsNull())
return;
try
{
OCC_CATCH_SIGNALS
// Store discretization of edges
BRepMesh::HDMapOfShapePairOfPolygon& aInternalEdges = aFaceAttribute->ChangeInternalEdges();
BRepMesh::DMapOfShapePairOfPolygon::Iterator aEdgeIt(*aInternalEdges);
for (; aEdgeIt.More(); aEdgeIt.Next())
{
const TopoDS_Edge& aEdge = TopoDS::Edge(aEdgeIt.Key());
const BRepMesh_PairOfPolygon& aPolyPair = aEdgeIt.Value();
const Handle(Poly_PolygonOnTriangulation)& aPolygon1 = aPolyPair.First();
const Handle(Poly_PolygonOnTriangulation)& aPolygon2 = aPolyPair.Last();
if (aPolygon1 == aPolygon2)
BRepMesh_ShapeTool::UpdateEdge(aEdge, aPolygon1, aTriangulation, aLoc);
else
BRepMesh_ShapeTool::UpdateEdge(aEdge, aPolygon1, aPolygon2, aTriangulation, aLoc);
}
}
catch (Standard_Failure)
{
myStatus |= BRepMesh_Failure;
} }
} }

93
src/BRepMesh/BRepMesh_IncrementalMesh.hxx
View File

@@ -14,21 +14,8 @@
#ifndef _BRepMesh_IncrementalMesh_HeaderFile #ifndef _BRepMesh_IncrementalMesh_HeaderFile
#define _BRepMesh_IncrementalMesh_HeaderFile #define _BRepMesh_IncrementalMesh_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <BRepMesh_FastDiscret.hxx>
#include <TopTools_MapOfShape.hxx>
#include <TopTools_DataMapOfShapeReal.hxx>
#include <BRepMesh_DiscretRoot.hxx> #include <BRepMesh_DiscretRoot.hxx>
#include <BRepMesh.hxx> #include <IMeshTools_Parameters.hxx>
#include <vector>
class Poly_Triangulation;
class TopoDS_Shape;
class TopoDS_Edge;
class TopoDS_Face;
//! Builds the mesh of a shape with respect of their //! Builds the mesh of a shape with respect of their
//! correctly triangulated parts //! correctly triangulated parts
@@ -56,15 +43,14 @@ public: //! @name mesher API
const Standard_Real theLinDeflection, const Standard_Real theLinDeflection,
const Standard_Boolean isRelative = Standard_False, const Standard_Boolean isRelative = Standard_False,
const Standard_Real theAngDeflection = 0.5, const Standard_Real theAngDeflection = 0.5,
const Standard_Boolean isInParallel = Standard_False, const Standard_Boolean isInParallel = Standard_False);
const Standard_Boolean adaptiveMin = Standard_False);
//! Constructor. //! Constructor.
//! Automatically calls method Perform. //! Automatically calls method Perform.
//! @param theShape shape to be meshed. //! @param theShape shape to be meshed.
//! @param theParameters - parameters of meshing //! @param theParameters - parameters of meshing
Standard_EXPORT BRepMesh_IncrementalMesh (const TopoDS_Shape& theShape, Standard_EXPORT BRepMesh_IncrementalMesh (const TopoDS_Shape& theShape,
const BRepMesh_FastDiscret::Parameters& theParameters); const IMeshTools_Parameters& theParameters);
//! Performs meshing ot the shape. //! Performs meshing ot the shape.
Standard_EXPORT virtual void Perform() Standard_OVERRIDE; Standard_EXPORT virtual void Perform() Standard_OVERRIDE;
@@ -72,13 +58,13 @@ public: //! @name mesher API
public: //! @name accessing to parameters. public: //! @name accessing to parameters.
//! Returns meshing parameters //! Returns meshing parameters
inline const BRepMesh_FastDiscret::Parameters& Parameters() const inline const IMeshTools_Parameters& Parameters() const
{ {
return myParameters; return myParameters;
} }
//! Returns modifiable meshing parameters //! Returns modifiable meshing parameters
inline BRepMesh_FastDiscret::Parameters& ChangeParameters() inline IMeshTools_Parameters& ChangeParameters()
{ {
return myParameters; return myParameters;
} }
@@ -117,78 +103,13 @@ public: //! @name plugin API
//! Discret() static method (thus applied only to Mesh Factories). //! Discret() static method (thus applied only to Mesh Factories).
Standard_EXPORT static void SetParallelDefault(const Standard_Boolean isInParallel); Standard_EXPORT static void SetParallelDefault(const Standard_Boolean isInParallel);
DEFINE_STANDARD_RTTIEXT(BRepMesh_IncrementalMesh,BRepMesh_DiscretRoot) DEFINE_STANDARD_RTTI_INLINE(BRepMesh_IncrementalMesh, BRepMesh_DiscretRoot)
protected: protected:
Standard_EXPORT virtual void init() Standard_OVERRIDE; IMeshTools_Parameters myParameters;
private:
//! Builds the incremental mesh for the shape.
void update();
//! Checks triangulation of the given face for consistency
//! with the chosen tolerance. If some edge of face has no
//! discrete representation triangulation will be calculated.
//! @param theFace face to be checked.
void update(const TopoDS_Face& theFace);
//! Checks discretization of the given edge for consistency
//! with the chosen tolerance.
//! @param theEdge edge to be checked.
void update(const TopoDS_Edge& theEdge);
//! Collects faces suitable for meshing.
void collectFaces();
//! Discretizes edges that have no associations with faces.
void discretizeFreeEdges();
//! Returns deflection of the given edge.
//! @param theEdge edge which tolerance should be taken.
Standard_Real edgeDeflection(const TopoDS_Edge& theEdge);
//! Returns deflection of the given face.
//! If relative flag is set, calculates relative deflection of the face
//! as an average value of relative deflection regarding face's edges.
//! Returns value of deflection set by user elsewhere.
Standard_Real faceDeflection(const TopoDS_Face& theFace);
//! Prepares the given face for meshing.
//! Nullifies triangulation of face and polygons of face's edges.
//! @param theFace face to be checked.
//! @param isWithCheck if TRUE, checks parameters of triangulation
//! existing in face. If its deflection satisfies the given value and
//! each edge of face has polygon corresponded to this triangulation,
//! method return FALSE.
//! @return TRUE in case if the given face should be meshed.
Standard_Boolean toBeMeshed(const TopoDS_Face& theFace,
const Standard_Boolean isWithCheck);
//! Stores mesh to the shape.
void commit();
//! Stores mesh of internal edges to the face.
void commitEdges(const TopoDS_Face& theFace);
//! Clears internal data structures.
void clear();
protected:
BRepMesh::DMapOfEdgeListOfTriangulationBool myEdges;
Handle(BRepMesh_FastDiscret) myMesh;
TopTools_DataMapOfShapeReal myEdgeDeflection;
NCollection_Vector<TopoDS_Face> myFaces;
BRepMesh_FastDiscret::Parameters myParameters;
Standard_Real myMaxShapeSize;
Standard_Boolean myModified; Standard_Boolean myModified;
Standard_Integer myStatus; Standard_Integer myStatus;
}; };
DEFINE_STANDARD_HANDLE(BRepMesh_IncrementalMesh,BRepMesh_DiscretRoot)
#endif #endif

4
src/BRepMesh/BRepMesh_OrientedEdge.hxx
View File

@@ -57,7 +57,7 @@ public:
//! Returns hash code for this edge. //! Returns hash code for this edge.
//! @param theUpper upper index in the container. //! @param theUpper upper index in the container.
//! @return hash code. //! @return hash code.
Standard_Integer HashCode(const Standard_Integer theUpper) const inline Standard_Integer HashCode(const Standard_Integer theUpper) const
{ {
return ::HashCode(myFirstNode + myLastNode, theUpper); return ::HashCode(myFirstNode + myLastNode, theUpper);
} }
@@ -71,7 +71,7 @@ public:
} }
//! Alias for IsEqual. //! Alias for IsEqual.
Standard_Boolean operator ==(const BRepMesh_OrientedEdge& Other) const inline Standard_Boolean operator ==(const BRepMesh_OrientedEdge& Other) const
{ {
return IsEqual(Other); return IsEqual(Other);
} }

20
src/BRepMesh/BRepMesh_SelectorOfDataStructureOfDelaun.cxx
View File

@@ -16,17 +16,13 @@
#include <BRepMesh_SelectorOfDataStructureOfDelaun.hxx> #include <BRepMesh_SelectorOfDataStructureOfDelaun.hxx>
#include <BRepMesh_PairOfIndex.hxx> #include <BRepMesh_PairOfIndex.hxx>
#include <BRepMesh_Edge.hxx>
//======================================================================= //=======================================================================
//function : Default constructor //function : Default constructor
//purpose : //purpose :
//======================================================================= //=======================================================================
BRepMesh_SelectorOfDataStructureOfDelaun::BRepMesh_SelectorOfDataStructureOfDelaun() BRepMesh_SelectorOfDataStructureOfDelaun::BRepMesh_SelectorOfDataStructureOfDelaun()
: myAllocator(new NCollection_IncAllocator(BRepMesh::MEMORY_BLOCK_SIZE_HUGE)),
myNodes (10, myAllocator),
myLinks (10, myAllocator),
myElements(10, myAllocator),
myFrontier(10, myAllocator)
{ {
} }
@@ -36,12 +32,7 @@ BRepMesh_SelectorOfDataStructureOfDelaun::BRepMesh_SelectorOfDataStructureOfDela
//======================================================================= //=======================================================================
BRepMesh_SelectorOfDataStructureOfDelaun::BRepMesh_SelectorOfDataStructureOfDelaun( BRepMesh_SelectorOfDataStructureOfDelaun::BRepMesh_SelectorOfDataStructureOfDelaun(
const Handle(BRepMesh_DataStructureOfDelaun)& theMesh) const Handle(BRepMesh_DataStructureOfDelaun)& theMesh)
: myAllocator(new NCollection_IncAllocator(BRepMesh::MEMORY_BLOCK_SIZE_HUGE)), : myMesh(theMesh)
myMesh (theMesh),
myNodes (10, myAllocator),
myLinks (10, myAllocator),
myElements(10, myAllocator),
myFrontier(10, myAllocator)
{ {
} }
@@ -76,7 +67,7 @@ void BRepMesh_SelectorOfDataStructureOfDelaun::NeighboursOf(
void BRepMesh_SelectorOfDataStructureOfDelaun::NeighboursOfNode( void BRepMesh_SelectorOfDataStructureOfDelaun::NeighboursOfNode(
const Standard_Integer theNodeIndex) const Standard_Integer theNodeIndex)
{ {
BRepMesh::ListOfInteger::Iterator aLinkIt( IMeshData::ListOfInteger::Iterator aLinkIt(
myMesh->LinksConnectedTo(theNodeIndex)); myMesh->LinksConnectedTo(theNodeIndex));
for (; aLinkIt.More(); aLinkIt.Next()) for (; aLinkIt.More(); aLinkIt.Next())
@@ -135,10 +126,7 @@ void BRepMesh_SelectorOfDataStructureOfDelaun::NeighboursOfElement(
void BRepMesh_SelectorOfDataStructureOfDelaun::NeighboursByEdgeOf( void BRepMesh_SelectorOfDataStructureOfDelaun::NeighboursByEdgeOf(
const BRepMesh_Triangle& theElement) const BRepMesh_Triangle& theElement)
{ {
Standard_Integer e[3]; const Standard_Integer(&e)[3] = theElement.myEdges;
Standard_Boolean o[3];
theElement.Edges(e, o);
for (Standard_Integer i = 0; i < 3; ++i) for (Standard_Integer i = 0; i < 3; ++i)
elementsOfLink(e[i]); elementsOfLink(e[i]);
} }

30
src/BRepMesh/BRepMesh_SelectorOfDataStructureOfDelaun.hxx
View File

@@ -14,25 +14,20 @@
#ifndef _BRepMesh_SelectorOfDataStructureOfDelaun_HeaderFile #ifndef _BRepMesh_SelectorOfDataStructureOfDelaun_HeaderFile
#define _BRepMesh_SelectorOfDataStructureOfDelaun_HeaderFile #define _BRepMesh_SelectorOfDataStructureOfDelaun_HeaderFile
#include <Standard.hxx> #include <Standard_Transient.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Macro.hxx>
#include <BRepMesh_DataStructureOfDelaun.hxx> #include <BRepMesh_DataStructureOfDelaun.hxx>
#include <BRepMesh.hxx>
#include <Standard_Integer.hxx>
#include <BRepMesh_Triangle.hxx> #include <BRepMesh_Triangle.hxx>
#include <IMeshData_Types.hxx>
class BRepMesh_Vertex; class BRepMesh_Vertex;
class BRepMesh_Edge; class BRepMesh_Edge;
//! Describes a selector and an iterator on a //! Describes a selector and an iterator on a
//! selector of components of a mesh. //! selector of components of a mesh.
class BRepMesh_SelectorOfDataStructureOfDelaun class BRepMesh_SelectorOfDataStructureOfDelaun : public Standard_Transient
{ {
public: public:
DEFINE_STANDARD_ALLOC
//! Default constructor. //! Default constructor.
Standard_EXPORT BRepMesh_SelectorOfDataStructureOfDelaun(); Standard_EXPORT BRepMesh_SelectorOfDataStructureOfDelaun();
@@ -75,41 +70,42 @@ public:
} }
//! Returns selected nodes. //! Returns selected nodes.
inline const BRepMesh::MapOfInteger& Nodes() const inline const IMeshData::MapOfInteger& Nodes() const
{ {
return myNodes; return myNodes;
} }
//! Returns selected links. //! Returns selected links.
inline const BRepMesh::MapOfInteger& Links() const inline const IMeshData::MapOfInteger& Links() const
{ {
return myLinks; return myLinks;
} }
//! Returns selected elements. //! Returns selected elements.
inline const BRepMesh::MapOfInteger& Elements() const inline const IMeshData::MapOfInteger& Elements() const
{ {
return myElements; return myElements;
} }
//! Gives the list of incices of frontier links. //! Gives the list of incices of frontier links.
inline const BRepMesh::MapOfInteger& FrontierLinks() const inline const IMeshData::MapOfInteger& FrontierLinks() const
{ {
return myFrontier; return myFrontier;
} }
DEFINE_STANDARD_RTTI_INLINE(BRepMesh_SelectorOfDataStructureOfDelaun, Standard_Transient)
private: private:
//! Collects elements connected to link with the given index. //! Collects elements connected to link with the given index.
void elementsOfLink(const Standard_Integer theIndex); void elementsOfLink(const Standard_Integer theIndex);
private: private:
Handle(NCollection_IncAllocator) myAllocator;
Handle(BRepMesh_DataStructureOfDelaun) myMesh; Handle(BRepMesh_DataStructureOfDelaun) myMesh;
BRepMesh::MapOfInteger myNodes; IMeshData::MapOfInteger myNodes;
BRepMesh::MapOfInteger myLinks; IMeshData::MapOfInteger myLinks;
BRepMesh::MapOfInteger myElements; IMeshData::MapOfInteger myElements;
BRepMesh::MapOfInteger myFrontier; IMeshData::MapOfInteger myFrontier;
}; };
#endif #endif

378
src/BRepMesh/BRepMesh_ShapeTool.cxx
View File

@@ -1,5 +1,6 @@
// Copyright (c) 1995-1999 Matra Datavision // Created on: 2016-04-19
// Copyright (c) 1999-2014 OPEN CASCADE SAS // Copyright (c) 2016 OPEN CASCADE SAS
// Created by: Oleg AGASHIN
// //
// This file is part of Open CASCADE Technology software library. // This file is part of Open CASCADE Technology software library.
// //
@@ -13,21 +14,20 @@
// commercial license or contractual agreement. // commercial license or contractual agreement.
#include <BRepMesh_ShapeTool.hxx> #include <BRepMesh_ShapeTool.hxx>
#include <IMeshData_Edge.hxx>
#include <Bnd_Box.hxx> #include <IMeshData_PCurve.hxx>
#include <TopoDS_Edge.hxx> #include <TopoDS_Vertex.hxx>
#include <BRepBndLib.hxx>
#include <TopoDS.hxx>
#include <BRep_Tool.hxx>
#include <TopExp_Explorer.hxx>
#include <BRepAdaptor_HSurface.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <Poly_Triangulation.hxx>
#include <BRep_Builder.hxx>
#include <TopExp.hxx> #include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <BRep_Tool.hxx>
#include <BRep_Builder.hxx>
#include <ShapeAnalysis_Edge.hxx>
#include <BRepAdaptor_Curve.hxx> #include <BRepAdaptor_Curve.hxx>
#include <Precision.hxx>
#include <Bnd_Box.hxx>
namespace { namespace
{
//! Auxilary struct to take a tolerance of edge. //! Auxilary struct to take a tolerance of edge.
struct EdgeTolerance struct EdgeTolerance
{ {
@@ -64,7 +64,7 @@ namespace {
} }
//======================================================================= //=======================================================================
//function : BoxMaxDimension //function : MaxFaceTolerance
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Real BRepMesh_ShapeTool::MaxFaceTolerance(const TopoDS_Face& theFace) Standard_Real BRepMesh_ShapeTool::MaxFaceTolerance(const TopoDS_Face& theFace)
@@ -85,7 +85,7 @@ Standard_Real BRepMesh_ShapeTool::MaxFaceTolerance(const TopoDS_Face& theFace)
void BRepMesh_ShapeTool::BoxMaxDimension(const Bnd_Box& theBox, void BRepMesh_ShapeTool::BoxMaxDimension(const Bnd_Box& theBox,
Standard_Real& theMaxDimension) Standard_Real& theMaxDimension)
{ {
if(theBox.IsVoid()) if (theBox.IsVoid())
return; return;
Standard_Real aMinX, aMinY, aMinZ, aMaxX, aMaxY, aMaxZ; Standard_Real aMinX, aMinY, aMinZ, aMaxX, aMaxY, aMaxZ;
@@ -95,98 +95,102 @@ void BRepMesh_ShapeTool::BoxMaxDimension(const Bnd_Box& theBox,
} }
//======================================================================= //=======================================================================
//function : RelativeEdgeDeflection //function : CheckAndUpdateFlags
//purpose : //purpose :
//======================================================================= //=======================================================================
Standard_Real BRepMesh_ShapeTool::RelativeEdgeDeflection( void BRepMesh_ShapeTool::CheckAndUpdateFlags (
const TopoDS_Edge& theEdge, const IMeshData::IEdgeHandle& theEdge,
const Standard_Real theDeflection, const IMeshData::IPCurveHandle& thePCurve)
const Standard_Real theMaxShapeSize,
Standard_Real& theAdjustmentCoefficient)
{ {
theAdjustmentCoefficient = 1.; if (!theEdge->GetSameParam () &&
Standard_Real aDefEdge = theDeflection; !theEdge->GetSameRange () &&
if(theEdge.IsNull()) theEdge->GetDegenerated ())
return aDefEdge;
Bnd_Box aBox;
BRepBndLib::Add(theEdge, aBox, Standard_False);
BoxMaxDimension(aBox, aDefEdge);
// Adjust resulting value in relation to the total size
theAdjustmentCoefficient = theMaxShapeSize / (2 * aDefEdge);
if (theAdjustmentCoefficient < 0.5)
theAdjustmentCoefficient = 0.5;
else if (theAdjustmentCoefficient > 2.)
theAdjustmentCoefficient = 2.;
return (theAdjustmentCoefficient * aDefEdge * theDeflection);
}
//=======================================================================
//function : FindUV
//purpose :
//=======================================================================
gp_XY BRepMesh_ShapeTool::FindUV(
const Standard_Integer theIndexOfPnt3d,
const gp_Pnt2d& thePnt2d,
const Standard_Real theMinDistance,
const Handle(BRepMesh_FaceAttribute)& theFaceAttribute)
{
const gp_XY& aPnt2d = thePnt2d.Coord();
BRepMesh::HDMapOfIntegerListOfXY& aLocation2D =
theFaceAttribute->ChangeLocation2D();
if (!aLocation2D->IsBound(theIndexOfPnt3d))
{ {
BRepMesh::ListOfXY aPoints2d; // Nothing to do worse.
aPoints2d.Append(aPnt2d); return;
aLocation2D->Bind(theIndexOfPnt3d, aPoints2d);
return aPnt2d;
} }
BRepMesh::ListOfXY& aPoints2d = aLocation2D->ChangeFind(theIndexOfPnt3d); const TopoDS_Edge& aEdge = theEdge->GetEdge ();
const TopoDS_Face& aFace = thePCurve->GetFace ().lock ()->GetFace ();
// Find the most closest 2d point to the given one. Handle (Geom_Curve) aCurve;
gp_XY aUV; Standard_Real aFirstParam, aLastParam;
Standard_Real aMinDist = RealLast(); Range (aEdge, aCurve, aFirstParam, aLastParam);
BRepMesh::ListOfXY::Iterator aPoint2dIt(aPoints2d); if (aCurve.IsNull())
for (; aPoint2dIt.More(); aPoint2dIt.Next())
{ {
const gp_XY& aCurPnt2d = aPoint2dIt.Value(); theEdge->SetDegenerated(Standard_True);
return;
}
Standard_Real aDist = (aPnt2d - aCurPnt2d).Modulus(); BRepAdaptor_Curve aCurveOnSurf(aEdge, aFace);
if (aDist < aMinDist) if (theEdge->GetSameParam () || theEdge->GetSameRange ())
{ {
aUV = aCurPnt2d; if (theEdge->GetSameRange ())
aMinDist = aDist; {
const Standard_Real aDiffFirst = aCurveOnSurf.FirstParameter () - aFirstParam;
const Standard_Real aDiffLast = aCurveOnSurf.LastParameter () - aLastParam;
theEdge->SetSameRange (
Abs (aDiffFirst) < Precision::PConfusion () &&
Abs (aDiffLast ) < Precision::PConfusion ());
if (!theEdge->GetSameRange())
{
theEdge->SetSameParam(Standard_False);
}
} }
} }
const Standard_Real aTolerance = theMinDistance; if (!theEdge->GetDegenerated ()/* || theEdge->GetSameParam ()*/)
// Get face limits
Standard_Real aDiffU = theFaceAttribute->GetUMax() - theFaceAttribute->GetUMin();
Standard_Real aDiffV = theFaceAttribute->GetVMax() - theFaceAttribute->GetVMin();
const Standard_Real Utol2d = .5 * aDiffU;
const Standard_Real Vtol2d = .5 * aDiffV;
const Handle(BRepAdaptor_HSurface)& aSurface = theFaceAttribute->Surface();
const gp_Pnt aPnt1 = aSurface->Value(aUV.X(), aUV.Y());
const gp_Pnt aPnt2 = aSurface->Value(aPnt2d.X(), aPnt2d.Y());
//! If selected point is too far from the given one in parametric space
//! or their positions in 3d are different, add the given point as unique.
if (Abs(aUV.X() - aPnt2d.X()) > Utol2d ||
Abs(aUV.Y() - aPnt2d.Y()) > Vtol2d ||
!aPnt1.IsEqual(aPnt2, aTolerance))
{ {
aUV = aPnt2d; TopoDS_Vertex aStartVertex, aEndVertex;
aPoints2d.Append(aUV); TopExp::Vertices (aEdge, aStartVertex, aEndVertex);
if (aStartVertex.IsNull() || aEndVertex.IsNull())
{
theEdge->SetDegenerated(Standard_True);
return;
} }
return aUV; if (aStartVertex.IsSame(aEndVertex))
{
const Standard_Integer aPointsNb = 20;
const Standard_Real aVertexTolerance = BRep_Tool::Tolerance (aStartVertex);
const Standard_Real aDu = (aLastParam - aFirstParam) / aPointsNb;
//const Standard_Real aEdgeTolerance = BRep_Tool::Tolerance (aEdge);
//const Standard_Real aSqEdgeTolerance = aEdgeTolerance * aEdgeTolerance;
gp_Pnt aPrevPnt;
aCurve->D0 (aFirstParam, aPrevPnt);
Standard_Real aLength = 0.0;
for (Standard_Integer i = 1; i <= aPointsNb; ++i)
{
const Standard_Real aParameter = aFirstParam + i * aDu;
// Calculation of the length of the edge in 3D
// in order to check degenerativity
gp_Pnt aPnt;
aCurve->D0 (aParameter, aPnt);
aLength += aPrevPnt.Distance (aPnt);
//if (theEdge->GetSameParam ())
//{
// // Check that points taken at the 3d and pcurve using
// // same parameter are within tolerance of an edge.
// gp_Pnt aPntOnSurf;
// aCurveOnSurf.D0 (aParameter, aPntOnSurf);
// theEdge->SetSameParam (aPnt.SquareDistance (aPntOnSurf) < aSqEdgeTolerance);
//}
if (aLength > aVertexTolerance /*&& !theEdge->GetSameParam()*/)
{
break;
}
aPrevPnt = aPnt;
}
theEdge->SetDegenerated (aLength < aVertexTolerance);
}
}
} }
//======================================================================= //=======================================================================
@@ -212,26 +216,69 @@ void BRepMesh_ShapeTool::AddInFace(
aBuilder.UpdateFace(theFace, theTriangulation); aBuilder.UpdateFace(theFace, theTriangulation);
} }
//======================================================================= //=======================================================================
//function : NullifyFace //function : NullifyFace
//purpose : //purpose :
//======================================================================= //=======================================================================
void BRepMesh_ShapeTool::NullifyFace(const TopoDS_Face& theFace) void BRepMesh_ShapeTool::NullifyFace (const TopoDS_Face& theFace)
{ {
BRep_Builder aBuilder; BRep_Builder aBuilder;
aBuilder.UpdateFace(theFace, Handle(Poly_Triangulation)()); aBuilder.UpdateFace (theFace, Handle (Poly_Triangulation)());
} }
//======================================================================= //=======================================================================
//function : NullifyEdge //function : NullifyEdge
//purpose : //purpose :
//======================================================================= //=======================================================================
void BRepMesh_ShapeTool::NullifyEdge( void BRepMesh_ShapeTool::NullifyEdge (
const TopoDS_Edge& theEdge, const TopoDS_Edge& theEdge,
const Handle(Poly_Triangulation)& theTriangulation, const Handle (Poly_Triangulation)& theTriangulation,
const TopLoc_Location& theLocation) const TopLoc_Location& theLocation)
{ {
UpdateEdge(theEdge, Handle(Poly_PolygonOnTriangulation)(), UpdateEdge (theEdge, Handle (Poly_PolygonOnTriangulation)(),
theTriangulation, theLocation);
}
//=======================================================================
//function : NullifyEdge
//purpose :
//=======================================================================
void BRepMesh_ShapeTool::NullifyEdge (
const TopoDS_Edge& theEdge,
const TopLoc_Location& theLocation)
{
BRep_Builder aBuilder;
aBuilder.UpdateEdge (theEdge, Handle (Poly_Polygon3D)(), theLocation);
}
//=======================================================================
//function : UpdateEdge
//purpose :
//=======================================================================
void BRepMesh_ShapeTool::UpdateEdge (
const TopoDS_Edge& theEdge,
const Handle (Poly_PolygonOnTriangulation)& thePolygon,
const Handle (Poly_Triangulation)& theTriangulation,
const TopLoc_Location& theLocation)
{
BRep_Builder aBuilder;
aBuilder.UpdateEdge (theEdge, thePolygon, theTriangulation, theLocation);
}
//=======================================================================
//function : UpdateEdge
//purpose :
//=======================================================================
void BRepMesh_ShapeTool::UpdateEdge (
const TopoDS_Edge& theEdge,
const Handle (Poly_PolygonOnTriangulation)& thePolygon1,
const Handle (Poly_PolygonOnTriangulation)& thePolygon2,
const Handle (Poly_Triangulation)& theTriangulation,
const TopLoc_Location& theLocation)
{
BRep_Builder aBuilder;
aBuilder.UpdateEdge (theEdge, thePolygon1, thePolygon2,
theTriangulation, theLocation); theTriangulation, theLocation);
} }
@@ -241,88 +288,85 @@ void BRepMesh_ShapeTool::NullifyEdge(
//======================================================================= //=======================================================================
void BRepMesh_ShapeTool::UpdateEdge( void BRepMesh_ShapeTool::UpdateEdge(
const TopoDS_Edge& theEdge, const TopoDS_Edge& theEdge,
const Handle(Poly_PolygonOnTriangulation)& thePolygon, const Handle(Poly_Polygon3D)& thePolygon)
const Handle(Poly_Triangulation)& theTriangulation,
const TopLoc_Location& theLocation)
{ {
BRep_Builder aBuilder; BRep_Builder aBuilder;
aBuilder.UpdateEdge(theEdge, thePolygon, theTriangulation, theLocation); aBuilder.UpdateEdge(theEdge, thePolygon);
}
//=======================================================================
//function : UpdateEdge
//purpose :
//=======================================================================
void BRepMesh_ShapeTool::UpdateEdge(
const TopoDS_Edge& theEdge,
const Handle(Poly_PolygonOnTriangulation)& thePolygon1,
const Handle(Poly_PolygonOnTriangulation)& thePolygon2,
const Handle(Poly_Triangulation)& theTriangulation,
const TopLoc_Location& theLocation)
{
BRep_Builder aBuilder;
aBuilder.UpdateEdge(theEdge, thePolygon1, thePolygon2,
theTriangulation, theLocation);
} }
//======================================================================= //=======================================================================
//function : UseLocation //function : UseLocation
//purpose : //purpose :
//======================================================================= //=======================================================================
gp_Pnt BRepMesh_ShapeTool::UseLocation(const gp_Pnt& thePnt, gp_Pnt BRepMesh_ShapeTool::UseLocation (
const gp_Pnt& thePnt,
const TopLoc_Location& theLoc) const TopLoc_Location& theLoc)
{ {
if (theLoc.IsIdentity()) if (theLoc.IsIdentity())
return thePnt;
return thePnt.Transformed(theLoc.Transformation());
}
//=======================================================================
//function : IsDegenerated
//purpose :
//=======================================================================
Standard_Boolean BRepMesh_ShapeTool::IsDegenerated(
const TopoDS_Edge& theEdge,
const TopoDS_Face& theFace)
{
// Get vertices
TopoDS_Vertex pBegin, pEnd;
TopExp::Vertices(theEdge, pBegin, pEnd);
if (pBegin.IsNull() || pEnd.IsNull())
return Standard_True;
if (BRep_Tool::Degenerated(theEdge))
return Standard_True;
if (!pBegin.IsSame(pEnd))
return Standard_False;
Standard_Real wFirst, wLast;
BRep_Tool::Range(theEdge, theFace, wFirst, wLast);
// calculation of the length of the edge in 3D
Standard_Real longueur = 0.0;
Standard_Real du = (wLast - wFirst) * 0.05;
gp_Pnt P1, P2;
BRepAdaptor_Curve BC(theEdge);
BC.D0(wFirst, P1);
Standard_Real tolV = BRep_Tool::Tolerance(pBegin);
Standard_Real tolV2 = 1.2 * tolV;
for (Standard_Integer l = 1; l <= 20; ++l)
{ {
BC.D0(wFirst + l * du, P2); return thePnt;
longueur += P1.Distance(P2);
if (longueur > tolV2)
break;
P1 = P2;
} }
if (longueur < tolV2) return thePnt.Transformed (theLoc.Transformation ());
return Standard_True; }
return Standard_False; //=======================================================================
//function : UVPoints
//purpose :
//=======================================================================
Standard_Boolean BRepMesh_ShapeTool::UVPoints (
const TopoDS_Edge& theEdge,
const TopoDS_Face& theFace,
gp_Pnt2d& theFirstPoint2d,
gp_Pnt2d& theLastPoint2d,
const Standard_Boolean isConsiderOrientation)
{
Handle (Geom2d_Curve) aCurve2d;
Standard_Real aFirstParam, aLastParam;
if (!Range(theEdge, theFace, aCurve2d, aFirstParam, aLastParam, isConsiderOrientation))
{
return Standard_False;
}
aCurve2d->D0 (aFirstParam, theFirstPoint2d);
aCurve2d->D0 (aLastParam, theLastPoint2d);
return Standard_True;
}
//=======================================================================
//function : Range
//purpose :
//=======================================================================
Standard_Boolean BRepMesh_ShapeTool::Range (
const TopoDS_Edge& theEdge,
const TopoDS_Face& theFace,
Handle (Geom2d_Curve)& thePCurve,
Standard_Real& theFirstParam,
Standard_Real& theLastParam,
const Standard_Boolean isConsiderOrientation)
{
ShapeAnalysis_Edge aEdge;
return aEdge.PCurve (theEdge, theFace, thePCurve,
theFirstParam, theLastParam,
isConsiderOrientation);
}
//=======================================================================
//function : Range
//purpose :
//=======================================================================
Standard_Boolean BRepMesh_ShapeTool::Range (
const TopoDS_Edge& theEdge,
Handle (Geom_Curve)& theCurve,
Standard_Real& theFirstParam,
Standard_Real& theLastParam,
const Standard_Boolean isConsiderOrientation)
{
ShapeAnalysis_Edge aEdge;
return aEdge.Curve3d (theEdge, theCurve,
theFirstParam, theLastParam,
isConsiderOrientation);
} }

141
src/BRepMesh/BRepMesh_ShapeTool.hxx
View File

@@ -1,4 +1,6 @@
// Copyright (c) 2013 OPEN CASCADE SAS // Created on: 2016-04-19
// Copyright (c) 2016 OPEN CASCADE SAS
// Created by: Oleg AGASHIN
// //
// This file is part of Open CASCADE Technology software library. // This file is part of Open CASCADE Technology software library.
// //
@@ -11,31 +13,29 @@
// Alternatively, this file may be used under the terms of Open CASCADE // Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement. // commercial license or contractual agreement.
#ifndef _BRepMesh_ShapeTool_HeaderFile #ifndef _BRepMesh_ShapeTool_HeaderFile
#define _BRepMesh_ShapeTool_HeaderFile #define _BRepMesh_ShapeTool_HeaderFile
#include <Standard.hxx> #include <Standard_Transient.hxx>
#include <Standard_DefineAlloc.hxx> #include <Standard_Handle.hxx>
#include <Standard_Macro.hxx> #include <Standard_Type.hxx>
#include <BRepAdaptor_HSurface.hxx> #include <IMeshData_Types.hxx>
#include <BRepMesh_FaceAttribute.hxx> #include <Poly_Triangulation.hxx>
#include <BRepMesh.hxx> #include <Poly_PolygonOnTriangulation.hxx>
class Poly_Triangulation; class Geom_Curve;
class Geom2d_Curve;
class Poly_Polygon3D;
class TopoDS_Face; class TopoDS_Face;
class TopoDS_Edge; class TopoDS_Edge;
class Bnd_Box; class Bnd_Box;
class TopoDS_Vertex;
class gp_XY;
class gp_Pnt2d;
class BRepMesh_ShapeTool //! Auxiliary class providing functionality to compute,
//! retrieve and store data to TopoDS and model shape.
class BRepMesh_ShapeTool : public Standard_Transient
{ {
public: public:
DEFINE_STANDARD_ALLOC
//! Returns maximum tolerance of the given face. //! Returns maximum tolerance of the given face.
//! Considers tolerances of edges and vertices contained in the given face. //! Considers tolerances of edges and vertices contained in the given face.
Standard_EXPORT static Standard_Real MaxFaceTolerance( Standard_EXPORT static Standard_Real MaxFaceTolerance(
@@ -48,39 +48,15 @@ public:
Standard_EXPORT static void BoxMaxDimension(const Bnd_Box& theBox, Standard_EXPORT static void BoxMaxDimension(const Bnd_Box& theBox,
Standard_Real& theMaxDimension); Standard_Real& theMaxDimension);
//! Returns relative deflection for edge with respect to shape size. //! Checks same parameter, same range and degenerativity attributes
//! @param theEdge edge for which relative deflection should be computed. //! using geometrical data of the given edge and updates edge model
//! @param theDeflection absolute deflection. //! by computed parameters in case of worst case - it can drop flags
//! @param theMaxShapeSize maximum size of a shape. //! same parameter and same range to False but never to True if it is
//! @param theAdjustmentCoefficient coefficient of adjustment between maximum //! already set to False. In contrary, it can also drop degenerated
//! size of shape and calculated relative deflection. //! flag to True, but never to False if it is already set to True.
//! @return relative deflection for the edge. Standard_EXPORT static void CheckAndUpdateFlags (
Standard_EXPORT static Standard_Real RelativeEdgeDeflection( const IMeshData::IEdgeHandle& theEdge,
const TopoDS_Edge& theEdge, const IMeshData::IPCurveHandle& thePCurve);
const Standard_Real theDeflection,
const Standard_Real theMaxShapeSize,
Standard_Real& theAdjustmentCoefficient);
//! Checks 2d representations of 3d point with the
//! given index for equality to avoid duplications.
//! @param theIndexOfPnt3d index of 3d point with which 2d
//! representation should be associated.
//! @param thePnt2d 2d representation of the point with the
//! given index.
//! @param theMinDistance minimum distance between vertices
//! regarding which they could be treated as distinct ones.
//! @param theFaceAttribute attributes contining data calculated
//! according to face geomtry and define limits of face in parametric
//! space. If defined, will be used instead of surface parameter.
//! @param theLocation2dMap map of 2d representations of 3d points.
//! @return given 2d point in case if 3d poind does not alredy have
//! the similar representation, otherwice 2d point corresponding to
//! existing representation will be returned.
Standard_EXPORT static gp_XY FindUV(
const Standard_Integer theIndexOfPnt3d,
const gp_Pnt2d& thePnt2d,
const Standard_Real theMinDistance,
const Handle(BRepMesh_FaceAttribute)& theFaceAttribute);
//! Stores the given triangulation into the given face. //! Stores the given triangulation into the given face.
//! @param theFace face to be updated by triangulation. //! @param theFace face to be updated by triangulation.
@@ -91,15 +67,22 @@ public:
//! Nullifies triangulation stored in the face. //! Nullifies triangulation stored in the face.
//! @param theFace face to be updated by null triangulation. //! @param theFace face to be updated by null triangulation.
Standard_EXPORT static void NullifyFace(const TopoDS_Face& theFace); Standard_EXPORT static void NullifyFace (const TopoDS_Face& theFace);
//! Nullifies polygon on triangulation stored in the edge. //! Nullifies polygon on triangulation stored in the edge.
//! @param theEdge edge to be updated by null polygon. //! @param theEdge edge to be updated by null polygon.
//! @param theTriangulation triangulation the given edge is associated to. //! @param theTriangulation triangulation the given edge is associated to.
//! @param theLocation face location. //! @param theLocation face location.
Standard_EXPORT static void NullifyEdge( Standard_EXPORT static void NullifyEdge (
const TopoDS_Edge& theEdge,
const Handle (Poly_Triangulation)& theTriangulation,
const TopLoc_Location& theLocation);
//! Nullifies 3d polygon stored in the edge.
//! @param theEdge edge to be updated by null polygon.
//! @param theLocation face location.
Standard_EXPORT static void NullifyEdge (
const TopoDS_Edge& theEdge, const TopoDS_Edge& theEdge,
const Handle(Poly_Triangulation)& theTriangulation,
const TopLoc_Location& theLocation); const TopLoc_Location& theLocation);
//! Updates the given edge by the given tessellated representation. //! Updates the given edge by the given tessellated representation.
@@ -107,11 +90,18 @@ public:
//! @param thePolygon tessellated representation of the edge to be stored. //! @param thePolygon tessellated representation of the edge to be stored.
//! @param theTriangulation triangulation the given edge is associated to. //! @param theTriangulation triangulation the given edge is associated to.
//! @param theLocation face location. //! @param theLocation face location.
Standard_EXPORT static void UpdateEdge (
const TopoDS_Edge& theEdge,
const Handle (Poly_PolygonOnTriangulation)& thePolygon,
const Handle (Poly_Triangulation)& theTriangulation,
const TopLoc_Location& theLocation);
//! Updates the given edge by the given tessellated representation.
//! @param theEdge edge to be updated.
//! @param thePolygon tessellated representation of the edge to be stored.
Standard_EXPORT static void UpdateEdge( Standard_EXPORT static void UpdateEdge(
const TopoDS_Edge& theEdge, const TopoDS_Edge& theEdge,
const Handle(Poly_PolygonOnTriangulation)& thePolygon, const Handle(Poly_Polygon3D)& thePolygon);
const Handle(Poly_Triangulation)& theTriangulation,
const TopLoc_Location& theLocation);
//! Updates the given seam edge by the given tessellated representations. //! Updates the given seam edge by the given tessellated representations.
//! @param theEdge edge to be updated. //! @param theEdge edge to be updated.
@@ -121,27 +111,46 @@ public:
//! reversed direction of the seam edge. //! reversed direction of the seam edge.
//! @param theTriangulation triangulation the given edge is associated to. //! @param theTriangulation triangulation the given edge is associated to.
//! @param theLocation face location. //! @param theLocation face location.
Standard_EXPORT static void UpdateEdge( Standard_EXPORT static void UpdateEdge (
const TopoDS_Edge& theEdge, const TopoDS_Edge& theEdge,
const Handle(Poly_PolygonOnTriangulation)& thePolygon1, const Handle (Poly_PolygonOnTriangulation)& thePolygon1,
const Handle(Poly_PolygonOnTriangulation)& thePolygon2, const Handle (Poly_PolygonOnTriangulation)& thePolygon2,
const Handle(Poly_Triangulation)& theTriangulation, const Handle (Poly_Triangulation)& theTriangulation,
const TopLoc_Location& theLocation); const TopLoc_Location& theLocation);
//! Applies location to the given point and return result. //! Applies location to the given point and return result.
//! @param thePnt point to be transformed. //! @param thePnt point to be transformed.
//! @param theLoc location to be applied. //! @param theLoc location to be applied.
Standard_EXPORT static gp_Pnt UseLocation(const gp_Pnt& thePnt, Standard_EXPORT static gp_Pnt UseLocation (
const gp_Pnt& thePnt,
const TopLoc_Location& theLoc); const TopLoc_Location& theLoc);
//! Checks is the given edge degenerated. //! Gets the strict UV locations of the extremities of the edge using pcurve.
//! Checks geometrical parameters in case if IsDegenerated flag is not set. Standard_EXPORT static Standard_Boolean UVPoints (
//! @param theEdge edge to be checked.
//! @param theFace face within which parametric space edge will be checked
//! for geometrical degenerativity.
Standard_EXPORT static Standard_Boolean IsDegenerated(
const TopoDS_Edge& theEdge, const TopoDS_Edge& theEdge,
const TopoDS_Face& theFace); const TopoDS_Face& theFace,
gp_Pnt2d& theFirstPoint2d,
gp_Pnt2d& theLastPoint2d,
const Standard_Boolean isConsiderOrientation = Standard_False);
//! Gets the parametric range of the given edge on the given face.
Standard_EXPORT static Standard_Boolean Range (
const TopoDS_Edge& theEdge,
const TopoDS_Face& theFace,
Handle (Geom2d_Curve)& thePCurve,
Standard_Real& theFirstParam,
Standard_Real& theLastParam,
const Standard_Boolean isConsiderOrientation = Standard_False);
//! Gets the 3d range of the given edge.
Standard_EXPORT static Standard_Boolean Range (
const TopoDS_Edge& theEdge,
Handle (Geom_Curve)& theCurve,
Standard_Real& theFirstParam,
Standard_Real& theLastParam,
const Standard_Boolean isConsiderOrientation = Standard_False);
DEFINE_STANDARD_RTTI_INLINE(BRepMesh_ShapeTool, Standard_Transient)
}; };
#endif #endif

66
src/BRepMesh/BRepMesh_Triangle.hxx
View File

@@ -34,14 +34,14 @@ public:
//! Default constructor. //! Default constructor.
BRepMesh_Triangle() BRepMesh_Triangle()
: myEdge1(0), : myMovability (BRepMesh_Free)
myEdge2(0),
myEdge3(0),
myOrientation1(Standard_False),
myOrientation2(Standard_False),
myOrientation3(Standard_False),
myMovability (BRepMesh_Free)
{ {
myEdges[0] = 0;
myEdges[1] = 0;
myEdges[2] = 0;
myOrientations[0] = Standard_False;
myOrientations[1] = Standard_False;
myOrientations[2] = Standard_False;
} }
//! Constructor. //! Constructor.
@@ -65,12 +65,8 @@ public:
const Standard_Boolean (&theOrientations)[3], const Standard_Boolean (&theOrientations)[3],
const BRepMesh_DegreeOfFreedom theMovability) const BRepMesh_DegreeOfFreedom theMovability)
{ {
myEdge1 = theEdges[0]; memcpy(myEdges, theEdges, sizeof(theEdges));
myEdge2 = theEdges[1]; memcpy(myOrientations, theOrientations, sizeof(theOrientations));
myEdge3 = theEdges[2];
myOrientation1 = theOrientations[0];
myOrientation2 = theOrientations[1];
myOrientation3 = theOrientations[2];
myMovability = theMovability; myMovability = theMovability;
} }
@@ -80,12 +76,8 @@ public:
inline void Edges(Standard_Integer (&theEdges)[3], inline void Edges(Standard_Integer (&theEdges)[3],
Standard_Boolean (&theOrientations)[3]) const Standard_Boolean (&theOrientations)[3]) const
{ {
theEdges[0] = myEdge1; memcpy(theEdges, myEdges, sizeof(myEdges));
theEdges[1] = myEdge2; memcpy(theOrientations, myOrientations, sizeof(myOrientations));
theEdges[2] = myEdge3;
theOrientations[0] = myOrientation1;
theOrientations[1] = myOrientation2;
theOrientations[2] = myOrientation3;
} }
//! Returns movability of the triangle. //! Returns movability of the triangle.
@@ -103,36 +95,36 @@ public:
//! Returns hash code for this triangle. //! Returns hash code for this triangle.
//! @param theUpper upper index in the container. //! @param theUpper upper index in the container.
//! @return hash code. //! @return hash code.
Standard_Integer HashCode(const Standard_Integer theUpper) const inline Standard_Integer HashCode(const Standard_Integer theUpper) const
{ {
return ::HashCode(myEdge1 + myEdge2 + myEdge3, theUpper); return ::HashCode(myEdges[0] + myEdges[1] + myEdges[2], theUpper);
} }
//! Checks for equality with another triangle. //! Checks for equality with another triangle.
//! @param theOther triangle to be checked against this one. //! @param theOther triangle to be checked against this one.
//! @return TRUE if equal, FALSE if not. //! @return TRUE if equal, FALSE if not.
Standard_Boolean IsEqual(const BRepMesh_Triangle& theOther) const inline Standard_Boolean IsEqual(const BRepMesh_Triangle& theOther) const
{ {
if (myMovability == BRepMesh_Deleted || theOther.myMovability == BRepMesh_Deleted) if (myMovability == BRepMesh_Deleted || theOther.myMovability == BRepMesh_Deleted)
return Standard_False; return Standard_False;
if (myEdge1 == theOther.myEdge1 && if (myEdges[0] == theOther.myEdges[0] &&
myEdge2 == theOther.myEdge2 && myEdges[1] == theOther.myEdges[1] &&
myEdge3 == theOther.myEdge3) myEdges[2] == theOther.myEdges[2])
{ {
return Standard_True; return Standard_True;
} }
if (myEdge1 == theOther.myEdge2 && if (myEdges[0] == theOther.myEdges[1] &&
myEdge2 == theOther.myEdge3 && myEdges[1] == theOther.myEdges[2] &&
myEdge3 == theOther.myEdge1) myEdges[2] == theOther.myEdges[0])
{ {
return Standard_True; return Standard_True;
} }
if (myEdge1 == theOther.myEdge3 && if (myEdges[0] == theOther.myEdges[2] &&
myEdge2 == theOther.myEdge1 && myEdges[1] == theOther.myEdges[0] &&
myEdge3 == theOther.myEdge2) myEdges[2] == theOther.myEdges[1])
{ {
return Standard_True; return Standard_True;
} }
@@ -141,19 +133,13 @@ public:
} }
//! Alias for IsEqual. //! Alias for IsEqual.
Standard_Boolean operator ==(const BRepMesh_Triangle& theOther) const inline Standard_Boolean operator ==(const BRepMesh_Triangle& theOther) const
{ {
return IsEqual(theOther); return IsEqual(theOther);
} }
private: Standard_Integer myEdges[3];
Standard_Boolean myOrientations[3];
Standard_Integer myEdge1;
Standard_Integer myEdge2;
Standard_Integer myEdge3;
Standard_Boolean myOrientation1;
Standard_Boolean myOrientation2;
Standard_Boolean myOrientation3;
BRepMesh_DegreeOfFreedom myMovability; BRepMesh_DegreeOfFreedom myMovability;
}; };

7
src/BRepMesh/BRepMesh_Vertex.hxx
View File

@@ -20,6 +20,7 @@
#include <Standard_Macro.hxx> #include <Standard_Macro.hxx>
#include <gp_XY.hxx> #include <gp_XY.hxx>
#include <BRepMesh_DegreeOfFreedom.hxx> #include <BRepMesh_DegreeOfFreedom.hxx>
#include <Precision.hxx>
//! Light weighted structure representing vertex //! Light weighted structure representing vertex
//! of the mesh in parametric space. Vertex could be //! of the mesh in parametric space. Vertex could be
@@ -106,7 +107,7 @@ public:
//! Returns hash code for this vertex. //! Returns hash code for this vertex.
//! @param theUpper upper index in the container. //! @param theUpper upper index in the container.
//! @return hash code. //! @return hash code.
Standard_Integer HashCode(const Standard_Integer Upper) const inline Standard_Integer HashCode(const Standard_Integer Upper) const
{ {
return ::HashCode(Floor(1e5 * myUV.X()) * Floor(1e5 * myUV.Y()), Upper); return ::HashCode(Floor(1e5 * myUV.X()) * Floor(1e5 * myUV.Y()), Upper);
} }
@@ -114,7 +115,7 @@ public:
//! Checks for equality with another vertex. //! Checks for equality with another vertex.
//! @param theOther vertex to be checked against this one. //! @param theOther vertex to be checked against this one.
//! @return TRUE if equal, FALSE if not. //! @return TRUE if equal, FALSE if not.
Standard_Boolean IsEqual(const BRepMesh_Vertex& theOther) const inline Standard_Boolean IsEqual(const BRepMesh_Vertex& theOther) const
{ {
if (myMovability == BRepMesh_Deleted || if (myMovability == BRepMesh_Deleted ||
theOther.myMovability == BRepMesh_Deleted) theOther.myMovability == BRepMesh_Deleted)
@@ -126,7 +127,7 @@ public:
} }
//! Alias for IsEqual. //! Alias for IsEqual.
Standard_Boolean operator ==(const BRepMesh_Vertex& Other) const inline Standard_Boolean operator ==(const BRepMesh_Vertex& Other) const
{ {
return IsEqual(Other); return IsEqual(Other);
} }

35
src/BRepMesh/BRepMesh_VertexInspector.hxx
View File

@@ -19,7 +19,7 @@
#include <Precision.hxx> #include <Precision.hxx>
#include <gp_XY.hxx> #include <gp_XY.hxx>
#include <gp_XYZ.hxx> #include <gp_XYZ.hxx>
#include <BRepMesh.hxx> #include <IMeshData_Types.hxx>
#include <NCollection_CellFilter.hxx> #include <NCollection_CellFilter.hxx>
#include <BRepMesh_Vertex.hxx> #include <BRepMesh_Vertex.hxx>
@@ -31,13 +31,14 @@ public:
//! Constructor. //! Constructor.
//! @param theAllocator memory allocator to be used by internal collections. //! @param theAllocator memory allocator to be used by internal collections.
BRepMesh_VertexInspector ( BRepMesh_VertexInspector(
const Handle(NCollection_IncAllocator)& theAllocator) const Handle(NCollection_IncAllocator)& theAllocator)
: myResIndices(theAllocator), : myIndex(0),
myVertices (new BRepMesh::VectorOfVertex), myMinSqDist(RealLast()),
myDelNodes (theAllocator) myVertices(new IMeshData::VectorOfVertex),
myDelNodes(theAllocator)
{ {
SetTolerance( Precision::Confusion() ); SetTolerance(Precision::Confusion());
} }
//! Registers the given vertex. //! Registers the given vertex.
@@ -106,35 +107,32 @@ public:
//! Set reference point to be checked. //! Set reference point to be checked.
inline void SetPoint(const gp_XY& thePoint) inline void SetPoint(const gp_XY& thePoint)
{ {
myResIndices.Clear(); myIndex = 0;
myMinSqDist = RealLast();
myPoint = thePoint; myPoint = thePoint;
} }
//! Returns index of point coinciding with regerence one. //! Returns index of point coinciding with regerence one.
inline Standard_Integer GetCoincidentPoint() const inline Standard_Integer GetCoincidentPoint() const
{ {
if ( myResIndices.Size() > 0 ) return myIndex;
{
return myResIndices.First();
}
return 0;
} }
//! Returns list with indexes of vertices that have movability attribute //! Returns list with indexes of vertices that have movability attribute
//! equal to BRepMesh_Deleted and can be replaced with another node. //! equal to BRepMesh_Deleted and can be replaced with another node.
inline const BRepMesh::ListOfInteger& GetListOfDelPoints() const inline const IMeshData::ListOfInteger& GetListOfDelPoints() const
{ {
return myDelNodes; return myDelNodes;
} }
//! Returns set of mesh vertices. //! Returns set of mesh vertices.
inline const BRepMesh::HVectorOfVertex& Vertices() const inline const Handle(IMeshData::VectorOfVertex)& Vertices() const
{ {
return myVertices; return myVertices;
} }
//! Returns set of mesh vertices for modification. //! Returns set of mesh vertices for modification.
inline BRepMesh::HVectorOfVertex& ChangeVertices() inline Handle(IMeshData::VectorOfVertex)& ChangeVertices()
{ {
return myVertices; return myVertices;
} }
@@ -153,10 +151,11 @@ public:
private: private:
Standard_Integer myIndex;
Standard_Real myMinSqDist;
Standard_Real myTolerance[2]; Standard_Real myTolerance[2];
BRepMesh::ListOfInteger myResIndices; Handle(IMeshData::VectorOfVertex) myVertices;
BRepMesh::HVectorOfVertex myVertices; IMeshData::ListOfInteger myDelNodes;
BRepMesh::ListOfInteger myDelNodes;
gp_XY myPoint; gp_XY myPoint;
}; };

14
src/BRepMesh/BRepMesh_VertexTool.cxx
View File

@@ -14,11 +14,7 @@
// commercial license or contractual agreement. // commercial license or contractual agreement.
#include <BRepMesh_VertexTool.hxx> #include <BRepMesh_VertexTool.hxx>
#include <gp_XY.hxx>
#include <gp_XYZ.hxx>
#include <Precision.hxx> #include <Precision.hxx>
#include <BRepMesh_Vertex.hxx>
#include <BRepMesh_VertexInspector.hxx>
//======================================================================= //=======================================================================
//function : Inspect //function : Inspect
@@ -45,8 +41,16 @@ NCollection_CellFilter_Action BRepMesh_VertexInspector::Inspect(
inTol = ((aVec.X() * aVec.X()) < myTolerance[0]) && inTol = ((aVec.X() * aVec.X()) < myTolerance[0]) &&
((aVec.Y() * aVec.Y()) < myTolerance[1]); ((aVec.Y() * aVec.Y()) < myTolerance[1]);
} }
if (inTol) if (inTol)
myResIndices.Append(theTarget); {
const Standard_Real aSqDist = aVec.SquareModulus();
if (aSqDist < myMinSqDist)
{
myMinSqDist = aSqDist;
myIndex = theTarget;
}
}
return CellFilter_Keep; return CellFilter_Keep;
} }

23
src/BRepMesh/BRepMesh_VertexTool.hxx
View File

@@ -15,26 +15,21 @@
#define _BRepMesh_VertexTool_HeaderFile #define _BRepMesh_VertexTool_HeaderFile
#include <NCollection_Array1.hxx> #include <NCollection_Array1.hxx>
#include <Standard.hxx> #include <Standard_Transient.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Macro.hxx>
#include <BRepMesh_VertexInspector.hxx> #include <BRepMesh_VertexInspector.hxx>
#include <BRepMesh.hxx>
#include <Standard_OStream.hxx> #include <Standard_OStream.hxx>
#include <gp_XYZ.hxx>
#include <gp_XY.hxx> #include <gp_XY.hxx>
#include <IMeshData_Types.hxx>
class BRepMesh_Vertex; class BRepMesh_Vertex;
//! Describes data structure intended to keep mesh nodes //! Describes data structure intended to keep mesh nodes
//! defined in UV space and implements functionality //! defined in UV space and implements functionality
//! providing their uniqueness regarding thir position. //! providing their uniqueness regarding their position.
class BRepMesh_VertexTool class BRepMesh_VertexTool : public Standard_Transient
{ {
public: public:
DEFINE_STANDARD_ALLOC
//! Constructor. //! Constructor.
//! @param theAllocator memory allocator to be used by internal collections. //! @param theAllocator memory allocator to be used by internal collections.
Standard_EXPORT BRepMesh_VertexTool( Standard_EXPORT BRepMesh_VertexTool(
@@ -104,13 +99,13 @@ public:
Standard_EXPORT void Delete(const Standard_Integer theIndex); Standard_EXPORT void Delete(const Standard_Integer theIndex);
//! Returns set of mesh vertices. //! Returns set of mesh vertices.
inline const BRepMesh::HVectorOfVertex& Vertices() const inline const Handle(IMeshData::VectorOfVertex)& Vertices() const
{ {
return mySelector.Vertices(); return mySelector.Vertices();
} }
//! Returns set of mesh vertices. //! Returns set of mesh vertices.
inline BRepMesh::HVectorOfVertex& ChangeVertices() inline Handle(IMeshData::VectorOfVertex)& ChangeVertices()
{ {
return mySelector.ChangeVertices(); return mySelector.ChangeVertices();
} }
@@ -155,7 +150,7 @@ public:
//! Returns the list with indexes of vertices that have movability attribute //! Returns the list with indexes of vertices that have movability attribute
//! equal to BRepMesh_Deleted and can be replaced with another node. //! equal to BRepMesh_Deleted and can be replaced with another node.
inline const BRepMesh::ListOfInteger& GetListOfDelNodes() const inline const IMeshData::ListOfInteger& GetListOfDelNodes() const
{ {
return mySelector.GetListOfDelPoints(); return mySelector.GetListOfDelPoints();
} }
@@ -163,6 +158,8 @@ public:
//! Prints statistics. //! Prints statistics.
Standard_EXPORT void Statistics(Standard_OStream& theStream) const; Standard_EXPORT void Statistics(Standard_OStream& theStream) const;
DEFINE_STANDARD_RTTI_INLINE(BRepMesh_VertexTool, Standard_Transient)
private: private:
//! Expands the given point according to specified tolerance. //! Expands the given point according to specified tolerance.
@@ -182,7 +179,7 @@ private:
private: private:
Handle(NCollection_IncAllocator) myAllocator; Handle(NCollection_IncAllocator) myAllocator;
BRepMesh::VertexCellFilter myCellFilter; IMeshData::VertexCellFilter myCellFilter;
BRepMesh_VertexInspector mySelector; BRepMesh_VertexInspector mySelector;
Standard_Real myTolerance[2]; Standard_Real myTolerance[2];
}; };

71
src/BRepMesh/FILES
View File

@@ -1,55 +1,84 @@
BRepMesh.hxx BRepMesh_BaseMeshAlgo.cxx
BRepMesh_BaseMeshAlgo.hxx
BRepMesh_BoundaryParamsRangeSplitter.hxx
BRepMesh_Circle.hxx BRepMesh_Circle.hxx
BRepMesh_CircleInspector.hxx BRepMesh_CircleInspector.hxx
BRepMesh_CircleTool.cxx BRepMesh_CircleTool.cxx
BRepMesh_CircleTool.hxx BRepMesh_CircleTool.hxx
BRepMesh_Classifier.cxx BRepMesh_Classifier.cxx
BRepMesh_Classifier.hxx BRepMesh_Classifier.hxx
BRepMesh_ConeRangeSplitter.hxx
BRepMesh_Context.cxx
BRepMesh_Context.hxx
BRepMesh_CurveTessellator.cxx
BRepMesh_CurveTessellator.hxx
BRepMesh_CylinderRangeSplitter.hxx
BRepMesh_DataStructureOfDelaun.cxx BRepMesh_DataStructureOfDelaun.cxx
BRepMesh_DataStructureOfDelaun.hxx BRepMesh_DataStructureOfDelaun.hxx
BRepMesh_DefaultRangeSplitter.hxx
BRepMesh_Deflection.cxx
BRepMesh_Deflection.hxx
BRepMesh_DegreeOfFreedom.hxx BRepMesh_DegreeOfFreedom.hxx
BRepMesh_Delaun.cxx BRepMesh_Delaun.cxx
BRepMesh_Delaun.hxx BRepMesh_Delaun.hxx
BRepMesh_DiscretFactory.cxx BRepMesh_DelaunayBaseMeshAlgo.cxx
BRepMesh_DelaunayBaseMeshAlgo.hxx
BRepMesh_DelaunayDeflectionControlMeshAlgo.hxx
BRepMesh_DelaunayNodeInsertionMeshAlgo.hxx
BRepMesh_DiscretFactory.hxx BRepMesh_DiscretFactory.hxx
BRepMesh_DiscretRoot.cxx BRepMesh_DiscretFactory.cxx
BRepMesh_DiscretRoot.hxx BRepMesh_DiscretRoot.hxx
BRepMesh_DiscretRoot.cxx
BRepMesh_Edge.hxx BRepMesh_Edge.hxx
BRepMesh_EdgeParameterProvider.cxx BRepMesh_EdgeDiscret.cxx
BRepMesh_EdgeDiscret.hxx
BRepMesh_EdgeParameterProvider.hxx BRepMesh_EdgeParameterProvider.hxx
BRepMesh_EdgeTessellationExtractor.cxx BRepMesh_EdgeTessellationExtractor.cxx
BRepMesh_EdgeTessellationExtractor.hxx BRepMesh_EdgeTessellationExtractor.hxx
BRepMesh_EdgeTessellator.cxx BRepMesh_FaceChecker.cxx
BRepMesh_EdgeTessellator.hxx BRepMesh_FaceChecker.hxx
BRepMesh_FaceAttribute.cxx BRepMesh_FaceDiscret.cxx
BRepMesh_FaceAttribute.hxx BRepMesh_FaceDiscret.hxx
BRepMesh_FactoryError.hxx BRepMesh_FactoryError.hxx
BRepMesh_FastDiscret.cxx
BRepMesh_FastDiscret.hxx
BRepMesh_FastDiscretFace.cxx
BRepMesh_FastDiscretFace.hxx
BRepMesh_GeomTool.cxx BRepMesh_GeomTool.cxx
BRepMesh_GeomTool.hxx BRepMesh_GeomTool.hxx
BRepMesh_IEdgeTool.cxx BRepMesh_IncAllocator.hxx
BRepMesh_IEdgeTool.hxx
BRepMesh_IncrementalMesh.cxx BRepMesh_IncrementalMesh.cxx
BRepMesh_IncrementalMesh.hxx BRepMesh_IncrementalMesh.hxx
BRepMesh_MeshAlgoFactory.cxx
BRepMesh_MeshAlgoFactory.hxx
BRepMesh_MeshBuilder.cxx
BRepMesh_MeshBuilder.hxx
BRepMesh_MeshTool.cxx
BRepMesh_MeshTool.hxx
BRepMesh_ModelBuilder.cxx
BRepMesh_ModelBuilder.hxx
BRepMesh_ModelHealer.cxx
BRepMesh_ModelHealer.hxx
BRepMesh_ModelPostProcessor.cxx
BRepMesh_ModelPostProcessor.hxx
BRepMesh_ModelPreProcessor.cxx
BRepMesh_ModelPreProcessor.hxx
BRepMesh_NodeInsertionMeshAlgo.hxx
BRepMesh_NURBSRangeSplitter.cxx
BRepMesh_NURBSRangeSplitter.hxx
BRepMesh_OrientedEdge.hxx BRepMesh_OrientedEdge.hxx
BRepMesh_PairOfIndex.hxx BRepMesh_PairOfIndex.hxx
BRepMesh_PairOfPolygon.hxx
BRepMesh_PluginEntryType.hxx BRepMesh_PluginEntryType.hxx
BRepMesh_PluginMacro.hxx BRepMesh_PluginMacro.hxx
BRepMesh_SelectorOfDataStructureOfDelaun.cxx BRepMesh_SelectorOfDataStructureOfDelaun.cxx
BRepMesh_SelectorOfDataStructureOfDelaun.hxx BRepMesh_SelectorOfDataStructureOfDelaun.hxx
BRepMesh_ShapeExplorer.cxx
BRepMesh_ShapeExplorer.hxx
BRepMesh_ShapeTool.cxx BRepMesh_ShapeTool.cxx
BRepMesh_ShapeTool.hxx BRepMesh_ShapeTool.hxx
BRepMesh_Status.hxx BRepMesh_ShapeVisitor.cxx
BRepMesh_Triangle.hxx BRepMesh_ShapeVisitor.hxx
BRepMesh_SphereRangeSplitter.hxx
BRepMesh_TorusRangeSplitter.hxx
BRepMesh_UVParamRangeSplitter.hxx
BRepMesh_Vertex.hxx BRepMesh_Vertex.hxx
BRepMesh_VertexInspector.hxx BRepMesh_VertexInspector.hxx
BRepMesh_VertexTool.cxx BRepMesh_VertexTool.cxx
BRepMesh_VertexTool.hxx BRepMesh_VertexTool.hxx
BRepMesh_WireChecker.cxx BRepMesh_Triangle.hxx
BRepMesh_WireChecker.hxx
BRepMesh_WireInterferenceChecker.cxx
BRepMesh_WireInterferenceChecker.hxx

2
src/DBRep/DBRep_DrawableShape.cxx
View File

@@ -840,7 +840,7 @@ void DBRep_DrawableShape::DisplayHiddenLines(Draw_Display& dis)
if (!strcmp(dout.GetType(id),"PERS")) focal = dout.Focal(id); if (!strcmp(dout.GetType(id),"PERS")) focal = dout.Focal(id);
Standard_Real Ang,Def; Standard_Real Ang,Def;
HLRBRep::PolyHLRAngleAndDeflection(myAng,Ang,Def); HLRBRep::PolyHLRAngleAndDeflection(myAng,Ang,Def);
BRepMesh_FastDiscret::Parameters aMeshParams; IMeshTools_Parameters aMeshParams;
aMeshParams.Relative = Standard_True; aMeshParams.Relative = Standard_True;
aMeshParams.Deflection = Def; aMeshParams.Deflection = Def;
aMeshParams.Angle = Ang; aMeshParams.Angle = Ang;

56
src/MeshTest/MeshTest.cxx
View File

@@ -28,8 +28,8 @@
#include <BRepMesh_DataStructureOfDelaun.hxx> #include <BRepMesh_DataStructureOfDelaun.hxx>
#include <BRepMesh_Delaun.hxx> #include <BRepMesh_Delaun.hxx>
#include <BRepMesh_Edge.hxx> #include <BRepMesh_Edge.hxx>
#include <BRepMesh_FastDiscret.hxx>
#include <BRepMesh_IncrementalMesh.hxx> #include <BRepMesh_IncrementalMesh.hxx>
#include <IMeshTools_Parameters.hxx>
#include <BRepMesh_Triangle.hxx> #include <BRepMesh_Triangle.hxx>
#include <BRepMesh_Vertex.hxx> #include <BRepMesh_Vertex.hxx>
#include <BRepTest.hxx> #include <BRepTest.hxx>
@@ -80,6 +80,8 @@
#include <TopoDS_Wire.hxx> #include <TopoDS_Wire.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx> #include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopTools_MapIteratorOfMapOfShape.hxx> #include <TopTools_MapIteratorOfMapOfShape.hxx>
#include <OSD_Timer.hxx>
#include <IMeshData_Status.hxx>
#include <stdio.h> #include <stdio.h>
//epa Memory leaks test //epa Memory leaks test
@@ -147,7 +149,6 @@ options:\n\
Standard_Boolean isInParallel = Standard_False; Standard_Boolean isInParallel = Standard_False;
Standard_Boolean isIntVertices = Standard_True; Standard_Boolean isIntVertices = Standard_True;
Standard_Boolean isControlSurDef = Standard_True; Standard_Boolean isControlSurDef = Standard_True;
Standard_Boolean isAdaptiveMin = Standard_False;
if (nbarg > 3) if (nbarg > 3)
{ {
@@ -167,8 +168,6 @@ options:\n\
isIntVertices = Standard_False; isIntVertices = Standard_False;
else if (aOpt == "-surf_def_off") else if (aOpt == "-surf_def_off")
isControlSurDef = Standard_False; isControlSurDef = Standard_False;
else if (aOpt == "-adaptive")
isAdaptiveMin = Standard_True;
else if (i < nbarg) else if (i < nbarg)
{ {
Standard_Real aVal = Draw::Atof(argv[i++]); Standard_Real aVal = Draw::Atof(argv[i++]);
@@ -185,7 +184,7 @@ options:\n\
di << "Incremental Mesh, multi-threading " di << "Incremental Mesh, multi-threading "
<< (isInParallel ? "ON" : "OFF") << "\n"; << (isInParallel ? "ON" : "OFF") << "\n";
BRepMesh_FastDiscret::Parameters aMeshParams; IMeshTools_Parameters aMeshParams;
aMeshParams.Deflection = aLinDeflection; aMeshParams.Deflection = aLinDeflection;
aMeshParams.Angle = aAngDeflection; aMeshParams.Angle = aAngDeflection;
aMeshParams.Relative = isRelative; aMeshParams.Relative = isRelative;
@@ -193,37 +192,56 @@ options:\n\
aMeshParams.MinSize = aMinSize; aMeshParams.MinSize = aMinSize;
aMeshParams.InternalVerticesMode = isIntVertices; aMeshParams.InternalVerticesMode = isIntVertices;
aMeshParams.ControlSurfaceDeflection = isControlSurDef; aMeshParams.ControlSurfaceDeflection = isControlSurDef;
aMeshParams.AdaptiveMin = isAdaptiveMin;
OSD_Timer aTimer;
aTimer.Start();
BRepMesh_IncrementalMesh aMesher (aShape, aMeshParams); BRepMesh_IncrementalMesh aMesher (aShape, aMeshParams);
aTimer.Stop();
aTimer.Show();
di << "Meshing statuses: "; di << "Meshing statuses: ";
Standard_Integer statusFlags = aMesher.GetStatusFlags(); const Standard_Integer aStatus = aMesher.GetStatusFlags();
if( !statusFlags ) if (!aStatus)
{ {
di << "NoError"; di << "NoError";
} }
else else
{ {
Standard_Integer i; Standard_Integer i;
for( i = 0; i < 4; i++ ) for (i = 0; i < 8; i++)
{ {
if( (statusFlags >> i) & (Standard_Integer)1 ) Standard_Integer aFlag = aStatus & (1 << i);
if (aFlag)
{ {
switch(i+1) switch ((IMeshData_Status) aFlag)
{ {
case 1: case IMeshData_OpenWire:
di << "OpenWire "; di << "OpenWire ";
break; break;
case 2: case IMeshData_SelfIntersectingWire:
di << "SelfIntersectingWire "; di << "SelfIntersectingWire ";
break; break;
case 3: case IMeshData_Failure:
di << "Failure "; di << "Failure ";
break; break;
case 4: case IMeshData_ReMesh:
di << "ReMesh "; di << "ReMesh ";
break; break;
case IMeshData_UnorientedWire:
di << "UnorientedWire ";
break;
case IMeshData_TooFewPoints:
di << "TooFewPoints ";
break;
case IMeshData_Outdated:
di << "Outdated ";
break;
case IMeshData_Reused:
di << "Reused ";
break;
case IMeshData_NoError:
default:
break;
} }
} }
} }
@@ -415,12 +433,10 @@ static Standard_Integer fastdiscret(Draw_Interpretor& di, Standard_Integer nbarg
const Standard_Real d = Draw::Atof(argv[2]); const Standard_Real d = Draw::Atof(argv[2]);
Bnd_Box B; IMeshTools_Parameters aParams;
BRepBndLib::Add(S,B);
BRepMesh_FastDiscret::Parameters aParams;
aParams.Deflection = d; aParams.Deflection = d;
aParams.Angle = 0.5; aParams.Angle = 0.5;
BRepMesh_FastDiscret MESH(B,aParams); BRepMesh_IncrementalMesh MESH(S,aParams);
//Standard_Integer NbIterations = MESH.NbIterations(); //Standard_Integer NbIterations = MESH.NbIterations();
//if (nbarg > 4) NbIterations = Draw::Atoi(argv[4]); //if (nbarg > 4) NbIterations = Draw::Atoi(argv[4]);
@@ -438,7 +454,7 @@ static Standard_Integer fastdiscret(Draw_Interpretor& di, Standard_Integer nbarg
for (ex.Init(S, TopAbs_FACE); ex.More(); ex.Next()) for (ex.Init(S, TopAbs_FACE); ex.More(); ex.Next())
aBuilder.UpdateFace(TopoDS::Face(ex.Current()),T); aBuilder.UpdateFace(TopoDS::Face(ex.Current()),T);
MESH.Perform(S); MESH.Perform();
TopoDS_Compound aCompGood, aCompFailed, aCompViolating; TopoDS_Compound aCompGood, aCompFailed, aCompViolating;

34
src/MeshTest/MeshTest_Debug.cxx
View File

@@ -13,13 +13,16 @@
// Alternatively, this file may be used under the terms of Open CASCADE // Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement. // commercial license or contractual agreement.
#include <BRepMesh_FaceAttribute.hxx>
#include <Draw_Segment3D.hxx> #include <Draw_Segment3D.hxx>
#include <DrawTrSurf_Polygon3D.hxx> #include <DrawTrSurf_Polygon3D.hxx>
#include <Draw.hxx> #include <Draw.hxx>
#include <TCollection_AsciiString.hxx> #include <TCollection_AsciiString.hxx>
#include <TColgp_Array1OfPnt.hxx> #include <TColgp_Array1OfPnt.hxx>
#include <Poly_Polygon3D.hxx> #include <Poly_Polygon3D.hxx>
#include <BRepMesh_Edge.hxx>
#include <BRepMesh_Vertex.hxx>
#include <BRepMesh_Triangle.hxx>
#include <BRepMesh_DataStructureOfDelaun.hxx>
// This file defines global functions not declared in any public header, // This file defines global functions not declared in any public header,
// intended for use from debugger prompt (Command Window in Visual Studio) // intended for use from debugger prompt (Command Window in Visual Studio)
@@ -28,15 +31,14 @@
//function : MeshTest_DrawLinks //function : MeshTest_DrawLinks
//purpose : Draw links from mesh data structure of type BRepMesh_FaceAttribute //purpose : Draw links from mesh data structure of type BRepMesh_FaceAttribute
//======================================================================= //=======================================================================
Standard_EXPORT const char* MeshTest_DrawLinks(const char* theNameStr, void* theFaceAttr) Standard_EXPORT const char* MeshTest_DrawLinks(const char* theNameStr, void* theDataStruct)
{ {
if (theNameStr == 0 || theFaceAttr == 0) if (theNameStr == 0 || theDataStruct == 0)
{ {
return "Error: name or face attribute is null"; return "Error: name or face attribute is null";
} }
try { try {
const Handle(BRepMesh_FaceAttribute)& aFaceAttr = *(Handle(BRepMesh_FaceAttribute)*)theFaceAttr; const Handle(BRepMesh_DataStructureOfDelaun)& aMeshData = *(Handle(BRepMesh_DataStructureOfDelaun)*)theDataStruct;
const Handle(BRepMesh_DataStructureOfDelaun)& aMeshData = aFaceAttr->ChangeStructure();
if (aMeshData.IsNull()) if (aMeshData.IsNull())
return "Null mesh data structure"; return "Null mesh data structure";
Standard_Integer nbLinks = aMeshData->NbLinks(); Standard_Integer nbLinks = aMeshData->NbLinks();
@@ -51,9 +53,9 @@ Standard_EXPORT const char* MeshTest_DrawLinks(const char* theNameStr, void* the
Standard_Integer n2 = aLink.LastNode(); Standard_Integer n2 = aLink.LastNode();
const BRepMesh_Vertex& aV1 = aMeshData->GetNode(n1); const BRepMesh_Vertex& aV1 = aMeshData->GetNode(n1);
const BRepMesh_Vertex& aV2 = aMeshData->GetNode(n2); const BRepMesh_Vertex& aV2 = aMeshData->GetNode(n2);
const gp_Pnt& aP1 = aFaceAttr->GetPoint(aV1); Handle(Draw_Segment3D) aSeg = new Draw_Segment3D(gp_Pnt(aV1.Coord().X(), aV1.Coord().Y(), 0),
const gp_Pnt& aP2 = aFaceAttr->GetPoint(aV2); gp_Pnt(aV2.Coord().X(), aV2.Coord().Y(), 0),
Handle(Draw_Segment3D) aSeg = new Draw_Segment3D(aP1, aP2, Draw_bleu); Draw_bleu);
Draw::Set((aName + "_" + i).ToCString(), aSeg); Draw::Set((aName + "_" + i).ToCString(), aSeg);
} }
return theNameStr; return theNameStr;
@@ -68,16 +70,16 @@ Standard_EXPORT const char* MeshTest_DrawLinks(const char* theNameStr, void* the
//function : MeshTest_DrawTriangles //function : MeshTest_DrawTriangles
//purpose : Draw triangles from mesh data structure of type BRepMesh_FaceAttribute //purpose : Draw triangles from mesh data structure of type BRepMesh_FaceAttribute
//======================================================================= //=======================================================================
Standard_EXPORT const char* MeshTest_DrawTriangles(const char* theNameStr, void* theFaceAttr) Standard_EXPORT const char* MeshTest_DrawTriangles(const char* theNameStr, void* theDataStruct)
{ {
if (theNameStr == 0 || theFaceAttr == 0) if (theNameStr == 0 || theDataStruct == 0)
{ {
return "Error: name or face attribute is null"; return "Error: name or face attribute is null";
} }
try { try {
const Handle(BRepMesh_FaceAttribute)& aFaceAttr = const Handle(BRepMesh_DataStructureOfDelaun)& aMeshData =
*(Handle(BRepMesh_FaceAttribute)*)theFaceAttr; *(Handle(BRepMesh_DataStructureOfDelaun)*)theDataStruct;
const Handle(BRepMesh_DataStructureOfDelaun)& aMeshData = aFaceAttr->ChangeStructure();
if (aMeshData.IsNull()) if (aMeshData.IsNull())
return "Null mesh data structure"; return "Null mesh data structure";
Standard_Integer nbElem = aMeshData->NbElements(); Standard_Integer nbElem = aMeshData->NbElements();
@@ -93,8 +95,10 @@ Standard_EXPORT const char* MeshTest_DrawTriangles(const char* theNameStr, void*
const BRepMesh_Vertex& aV1 = aMeshData->GetNode(n[0]); const BRepMesh_Vertex& aV1 = aMeshData->GetNode(n[0]);
const BRepMesh_Vertex& aV2 = aMeshData->GetNode(n[1]); const BRepMesh_Vertex& aV2 = aMeshData->GetNode(n[1]);
const BRepMesh_Vertex& aV3 = aMeshData->GetNode(n[2]); const BRepMesh_Vertex& aV3 = aMeshData->GetNode(n[2]);
gp_Pnt aP[4] = { aFaceAttr->GetPoint(aV1), aFaceAttr->GetPoint(aV2), gp_Pnt aP[4] = { gp_Pnt(aV1.Coord().X(), aV1.Coord().Y(), 0),
aFaceAttr->GetPoint(aV3), aFaceAttr->GetPoint(aV1) }; gp_Pnt(aV2.Coord().X(), aV2.Coord().Y(), 0),
gp_Pnt(aV3.Coord().X(), aV3.Coord().Y(), 0),
gp_Pnt(aV1.Coord().X(), aV1.Coord().Y(), 0) };
TColgp_Array1OfPnt aPnts(aP[0], 1, 4); TColgp_Array1OfPnt aPnts(aP[0], 1, 4);
Handle(Poly_Polygon3D) aPoly = new Poly_Polygon3D(aPnts); Handle(Poly_Polygon3D) aPoly = new Poly_Polygon3D(aPnts);
Handle(DrawTrSurf_Polygon3D) aDPoly = new DrawTrSurf_Polygon3D(aPoly); Handle(DrawTrSurf_Polygon3D) aDPoly = new DrawTrSurf_Polygon3D(aPoly);

2
src/MeshTest/MeshTest_DrawableMesh.cxx
View File

@@ -29,7 +29,7 @@
#include <BRepMesh_Triangle.hxx> #include <BRepMesh_Triangle.hxx>
#include <BRepMesh_DataStructureOfDelaun.hxx> #include <BRepMesh_DataStructureOfDelaun.hxx>
#include <TopExp_Explorer.hxx> #include <TopExp_Explorer.hxx>
#include <BRep_Tool.hxx>
IMPLEMENT_STANDARD_RTTIEXT(MeshTest_DrawableMesh,Draw_Drawable3D) IMPLEMENT_STANDARD_RTTIEXT(MeshTest_DrawableMesh,Draw_Drawable3D)

3
src/QABugs/QABugs_11.cxx
View File

@@ -1245,6 +1245,7 @@ static Standard_Integer OCC22 (Draw_Interpretor& di, Standard_Integer argc, cons
#include <TopTools_DataMapIteratorOfDataMapOfShapeShape.hxx> #include <TopTools_DataMapIteratorOfDataMapOfShapeShape.hxx>
#include <BRepMesh_IncrementalMesh.hxx> #include <BRepMesh_IncrementalMesh.hxx>
#include <IMeshTools_Parameters.hxx>
//======================================================================= //=======================================================================
//function : OCC24 //function : OCC24
@@ -1309,7 +1310,7 @@ static Standard_Integer OCC369(Draw_Interpretor& di, Standard_Integer argc, cons
if(aShape.IsNull()) {di << "OCC369 FAULTY. Entry shape is NULL \n"; return 0;} if(aShape.IsNull()) {di << "OCC369 FAULTY. Entry shape is NULL \n"; return 0;}
// 3. Build mesh // 3. Build mesh
BRepMesh_FastDiscret::Parameters aMeshParams; IMeshTools_Parameters aMeshParams;
aMeshParams.Relative = Standard_True; aMeshParams.Relative = Standard_True;
aMeshParams.Deflection = 0.2; aMeshParams.Deflection = 0.2;
aMeshParams.Angle = M_PI / 6; aMeshParams.Angle = M_PI / 6;

10
src/SelectMgr/SelectMgr_TriangularFrustumSet.cxx
View File

@@ -37,11 +37,11 @@ void SelectMgr_TriangularFrustumSet::Build (const TColgp_Array1OfPnt2d& thePoint
Handle(BRepMesh_DataStructureOfDelaun) aMeshStructure = new BRepMesh_DataStructureOfDelaun(anAllocator); Handle(BRepMesh_DataStructureOfDelaun) aMeshStructure = new BRepMesh_DataStructureOfDelaun(anAllocator);
Standard_Integer aPtsLower = thePoints.Lower(); Standard_Integer aPtsLower = thePoints.Lower();
Standard_Integer aPtsUpper = thePoints.Upper(); Standard_Integer aPtsUpper = thePoints.Upper();
BRepMesh::Array1OfInteger anIndexes (0, thePoints.Length() - 1); IMeshData::VectorOfInteger anIndexes(aPtsUpper - aPtsLower, anAllocator);
for (Standard_Integer aPtIdx = aPtsLower; aPtIdx <= aPtsUpper; ++aPtIdx) for (Standard_Integer aPtIdx = aPtsLower; aPtIdx <= aPtsUpper; ++aPtIdx)
{ {
BRepMesh_Vertex aVertex (thePoints.Value (aPtIdx).XY(), aPtIdx, BRepMesh_Frontier); BRepMesh_Vertex aVertex(thePoints.Value(aPtIdx).XY(), aPtIdx, BRepMesh_Frontier);
anIndexes.ChangeValue (aPtIdx - aPtsLower) = aMeshStructure->AddNode (aVertex); anIndexes.Append(aMeshStructure->AddNode(aVertex));
} }
Standard_Real aPtSum = 0; Standard_Real aPtSum = 0;
@@ -64,11 +64,11 @@ void SelectMgr_TriangularFrustumSet::Build (const TColgp_Array1OfPnt2d& thePoint
} }
BRepMesh_Delaun aTriangulation (aMeshStructure, anIndexes); BRepMesh_Delaun aTriangulation (aMeshStructure, anIndexes);
const BRepMesh::MapOfInteger& aTriangles = aMeshStructure->ElementsOfDomain(); const IMeshData::MapOfInteger& aTriangles = aMeshStructure->ElementsOfDomain();
if (aTriangles.Extent() < 1) if (aTriangles.Extent() < 1)
return; return;
BRepMesh::MapOfInteger::Iterator aTriangleIt (aTriangles); IMeshData::IteratorOfMapOfInteger aTriangleIt (aTriangles);
for (; aTriangleIt.More(); aTriangleIt.Next()) for (; aTriangleIt.More(); aTriangleIt.Next())
{ {
const Standard_Integer aTriangleId = aTriangleIt.Key(); const Standard_Integer aTriangleId = aTriangleIt.Key();

2
src/StdPrs/StdPrs_HLRPolyShape.cxx
View File

@@ -68,7 +68,7 @@ void StdPrs_HLRPolyShape::Add(const Handle (Prs3d_Presentation)& aPresentation,
{ {
const Standard_Boolean aRel = aDrawer->TypeOfDeflection() == Aspect_TOD_RELATIVE; const Standard_Boolean aRel = aDrawer->TypeOfDeflection() == Aspect_TOD_RELATIVE;
Standard_Real aDef = aRel ? aDrawer->HLRDeviationCoefficient() : aDrawer->MaximalChordialDeviation(); Standard_Real aDef = aRel ? aDrawer->HLRDeviationCoefficient() : aDrawer->MaximalChordialDeviation();
BRepMesh_FastDiscret::Parameters aMeshParams; IMeshTools_Parameters aMeshParams;
aMeshParams.Relative = aRel; aMeshParams.Relative = aRel;
aMeshParams.Angle = aDrawer->HLRAngle(); aMeshParams.Angle = aDrawer->HLRAngle();
aMeshParams.Deflection = aDef; aMeshParams.Deflection = aDef;

13
src/TKMesh/EXTERNLIB
View File

@@ -1,9 +1,8 @@
TKBRep
TKMath
TKernel TKernel
TKG2d TKMath
TKG3d TKBRep
TKGeomBase
TKTopAlgo TKTopAlgo
TKGeomAlgo TKShHealing
CSF_TBB TKGeomBase
TKG3d
TKG2d

3
src/TKMesh/PACKAGES
View File

@@ -1 +1,4 @@
IMeshData
IMeshTools
BRepMeshData
BRepMesh BRepMesh