OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-03 17:56:21 +03:00
Code Packages Releases Activity

0023106: BRepMesh_IncrementalMesh returns wrong status

Browse Source 
Fix compilation errors on Linux platform

Squeeze compilation warnings on Linux

Fix regressions

Back RemoveFaceAttribute for further reasons

Fix retrieving of polygon by index

Fix applying of location

Test case for issue CR23106

Fix memory leak regression 'test bugs vis bug79' occurred due to incorrect memory cleaning of inherited objects by MMgtRaw::Free through BRepMesh_IEdgeTool;

Replace BRepMesh_PDiscretRoot by pure pointer to BRepMesh_DiscretRoot;

Fix IVtkOCC_ShapeMesher.
This commit is contained in:
oan 2014-09-26 16:31:27 +04:00 committed by bugmaster
parent 709e97a0c1
commit ceb418e13f
41 changed files with 3926 additions and 3595 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
adm/UDLIST
View File

@ -182,7 +182,7 @@ p TopOpeBRepBuild
p TopOpeBRepDS
p TopOpeBRepTool
p TopTrans
p XBRepMesh
n XBRepMesh
t TKBO
t TKBool
t TKFeat

6
src/BRepMesh/BRepMesh.cdl
View File

@ -54,8 +54,6 @@ is
imported Circle from BRepMesh;
imported DiscretRoot from BRepMesh;
imported DiscretFactory from BRepMesh;
--
pointer PDiscretRoot to DiscretRoot from BRepMesh;
imported ShapeTool from BRepMesh;
imported Collections from BRepMesh;
@ -66,6 +64,10 @@ is
imported WireInterferenceChecker from BRepMesh;
imported EdgeChecker from BRepMesh;
imported FaceChecker from BRepMesh;
imported EdgeParameterProvider from BRepMesh;
imported IEdgeTool from BRepMesh;
imported EdgeTessellationExtractor from BRepMesh;
imported EdgeTessellator from BRepMesh;
primitive PluginEntryType;

5
src/BRepMesh/BRepMesh_Collections.hxx
View File

@ -40,6 +40,7 @@
#include <BRepMesh_Circle.hxx>
#include <TopTools_ShapeMapHasher.hxx>
#include <Handle_Poly_Triangulation.hxx>
#include <TopoDS_Face.hxx>
#include <vector>
@ -48,7 +49,6 @@ class TopoDS_Shape;
class TopoDS_Face;
class TopoDS_Edge;
class TopoDS_Vertex;
class BRepMesh_FaceAttribute;
class Handle_BRepMesh_FaceAttribute;
class BRepMesh_VertexInspector;
class BRepMesh_CircleInspector;
@ -132,6 +132,9 @@ namespace BRepMeshCol
//! Handles
typedef N_HANDLE<MapOfInteger> HMapOfInteger;
typedef N_HANDLE<IMapOfInteger> HIMapOfInteger;
typedef N_HANDLE<DMapOfShapePairOfPolygon> HDMapOfShapePairOfPolygon;
typedef N_HANDLE<DMapOfIntegerPnt> HDMapOfIntegerPnt;
typedef N_HANDLE<BRepMesh_Classifier> HClassifier;
typedef N_HANDLE<BndBox2dTree> HBndBox2dTree;
typedef N_HANDLE<Array1OfSegments> HArray1OfSegments;

57
src/BRepMesh/BRepMesh_Delaun.cxx
View File

@ -75,10 +75,9 @@ namespace {
//function : BRepMesh_Delaun
//purpose : Creates the triangulation with an empty Mesh data structure
//=======================================================================
BRepMesh_Delaun::BRepMesh_Delaun( BRepMeshCol::Array1OfVertexOfDelaun& theVertices,
const Standard_Boolean isPositive )
: myIsPositiveOrientation( isPositive ),
myCircles( theVertices.Length(), new NCollection_IncAllocator() )
BRepMesh_Delaun::BRepMesh_Delaun(
BRepMeshCol::Array1OfVertexOfDelaun& theVertices)
: myCircles( theVertices.Length(), new NCollection_IncAllocator() )
{
if ( theVertices.Length() > 2 )
{
@ -92,11 +91,10 @@ BRepMesh_Delaun::BRepMesh_Delaun( BRepMeshCol::Array1OfVertexOfDelaun& theVertic
//function : BRepMesh_Delaun
//purpose : Creates the triangulation with and existent Mesh data structure
//=======================================================================
BRepMesh_Delaun::BRepMesh_Delaun( const Handle( BRepMesh_DataStructureOfDelaun )& theOldMesh,
BRepMeshCol::Array1OfVertexOfDelaun& theVertices,
const Standard_Boolean isPositive )
: myIsPositiveOrientation( isPositive ),
myCircles( theVertices.Length(), theOldMesh->Allocator() )
BRepMesh_Delaun::BRepMesh_Delaun(
const Handle( BRepMesh_DataStructureOfDelaun )& theOldMesh,
BRepMeshCol::Array1OfVertexOfDelaun& theVertices)
: myCircles( theVertices.Length(), theOldMesh->Allocator() )
{
myMeshData = theOldMesh;
if ( theVertices.Length() > 2 )
@ -107,11 +105,10 @@ BRepMesh_Delaun::BRepMesh_Delaun( const Handle( BRepMesh_DataStructureOfDelaun )
//function : BRepMesh_Delaun
//purpose : Creates the triangulation with and existent Mesh data structure
//=======================================================================
BRepMesh_Delaun::BRepMesh_Delaun( const Handle( BRepMesh_DataStructureOfDelaun )& theOldMesh,
BRepMeshCol::Array1OfInteger& theVertexIndices,
const Standard_Boolean isPositive )
: myIsPositiveOrientation( isPositive ),
myCircles( theVertexIndices.Length(), theOldMesh->Allocator() )
BRepMesh_Delaun::BRepMesh_Delaun(
const Handle( BRepMesh_DataStructureOfDelaun )& theOldMesh,
BRepMeshCol::Array1OfInteger& theVertexIndices)
: myCircles( theVertexIndices.Length(), theOldMesh->Allocator() )
{
myMeshData = theOldMesh;
if ( theVertexIndices.Length() > 2 )
@ -199,14 +196,6 @@ void BRepMesh_Delaun::superMesh( const Bnd_Box2d& theBox )
mySupVert[2] = myMeshData->AddNode(
BRepMesh_Vertex( aMaxX + aDelta, aMinY - aDeltaMin, BRepMesh_Free ) );
if ( !myIsPositiveOrientation )
{
Standard_Integer aTmp;
aTmp = mySupVert[1];
mySupVert[1] = mySupVert[2];
mySupVert[2] = aTmp;
}
Standard_Integer e[3];
Standard_Boolean o[3];
for (Standard_Integer aNodeId = 0; aNodeId < 3; ++aNodeId)
@ -354,13 +343,6 @@ void BRepMesh_Delaun::createTriangles ( const Standard_Integer theVer
continue;
}
Standard_Boolean isSensOK;
if ( myIsPositiveOrientation )
isSensOK = ( aDist12 > 0. && aDist23 > 0.);
else
isSensOK = ( aDist12 < 0. && aDist23 < 0.);
BRepMesh_Edge aFirstLink( aNodes[1], aNodes[0], BRepMesh_Free );
BRepMesh_Edge aLastLink ( aNodes[2], aNodes[1], BRepMesh_Free );
@ -369,7 +351,8 @@ void BRepMesh_Delaun::createTriangles ( const Standard_Integer theVer
isPositive ? anEdgeId : -anEdgeId,
myMeshData->AddLink( aLastLink ) };
if ( isSensOK )
Standard_Boolean isSensOK = (aDist12 > 0. && aDist23 > 0.);
if (isSensOK)
{
Standard_Integer anEdges[3];
Standard_Boolean anEdgesOri[3];
@ -935,8 +918,7 @@ Standard_Integer BRepMesh_Delaun::findNextPolygonLink(
{
// Find the next link having the greatest angle
// respect to a direction of a reference one
Standard_Real aMaxAngle = myIsPositiveOrientation ?
RealFirst() : RealLast();
Standard_Real aMaxAngle = RealFirst();
Standard_Integer aNextLinkId = 0;
BRepMeshCol::ListOfInteger::Iterator aLinkIt( myMeshData->LinksConnectedTo( thePivotNode ) );
@ -996,11 +978,8 @@ Standard_Integer BRepMesh_Delaun::findNextPolygonLink(
}
}
if ( ( myIsPositiveOrientation && anAngle <= aMaxAngle ) ||
(!myIsPositiveOrientation && anAngle >= aMaxAngle ) )
{
if (anAngle <= aMaxAngle)
continue;
}
Standard_Boolean isCheckEndPoints = ( anOtherNode != theFirstNode );
@ -1802,12 +1781,8 @@ void BRepMesh_Delaun::meshSimplePolygon( BRepMeshCol::SequenceOfInteger& thePoly
Standard_Real aDist = aRefEdgeDir ^ aDistanceDir;
Standard_Real aAngle = Abs( aRefEdgeDir.Angle(aDistanceDir) );
Standard_Real anAbsDist = Abs( aDist );
if ( ( anAbsDist < Precision ) ||
( myIsPositiveOrientation && aDist < 0. ) ||
(!myIsPositiveOrientation && aDist > 0. ) )
{
if (anAbsDist < Precision || aDist < 0.)
continue;
}
if ( ( anAbsDist >= aMinDist ) &&
( aAngle <= aOptAngle || aAngle > AngDeviation90Deg ) )

10
src/BRepMesh/BRepMesh_Delaun.hxx
View File

@ -40,18 +40,15 @@ public:
DEFINE_STANDARD_ALLOC
//! Creates the triangulation with an empty Mesh data structure.
Standard_EXPORT BRepMesh_Delaun (BRepMeshCol::Array1OfVertexOfDelaun& theVertices,
const Standard_Boolean isPositive = Standard_True);
Standard_EXPORT BRepMesh_Delaun (BRepMeshCol::Array1OfVertexOfDelaun& theVertices);
//! Creates the triangulation with an existent Mesh data structure.
Standard_EXPORT BRepMesh_Delaun (const Handle(BRepMesh_DataStructureOfDelaun)& theOldMesh,
BRepMeshCol::Array1OfVertexOfDelaun& theVertices,
const Standard_Boolean isPositive = Standard_True);
BRepMeshCol::Array1OfVertexOfDelaun& theVertices);
//! Creates the triangulation with an existant Mesh data structure.
Standard_EXPORT BRepMesh_Delaun (const Handle(BRepMesh_DataStructureOfDelaun)& theOldMesh,
BRepMeshCol::Array1OfInteger& theVertexIndices,
const Standard_Boolean isPositive = Standard_True);
BRepMeshCol::Array1OfInteger& theVertexIndices);
//! Initializes the triangulation with an array of vertices.
Standard_EXPORT void Init (BRepMeshCol::Array1OfVertexOfDelaun& theVertices);
@ -307,7 +304,6 @@ private:
private:
Handle(BRepMesh_DataStructureOfDelaun) myMeshData;
Standard_Boolean myIsPositiveOrientation;
BRepMesh_CircleTool myCircles;
Standard_Integer mySupVert[3];
BRepMesh_Triangle mySupTrian;

6
src/BRepMesh/BRepMesh_DiscretFactory.cxx
View File

@ -18,7 +18,7 @@
#include <OSD_SharedLibrary.hxx>
#include <OSD_Function.hxx>
#include <BRepMesh_IncrementalMesh.hxx>
#include <BRepMesh_PDiscretRoot.hxx>
#include <BRepMesh_DiscretRoot.hxx>
namespace
{
@ -145,7 +145,7 @@ Standard_Boolean BRepMesh_DiscretFactory::SetDefault(
}
// try to create dummy tool
BRepMesh_PDiscretRoot anInstancePtr = NULL;
BRepMesh_DiscretRoot* anInstancePtr = NULL;
Standard_Integer anErr = aFunc (TopoDS_Shape(), 0.001, 0.1, anInstancePtr);
if (anErr != 0 || anInstancePtr == NULL)
{
@ -174,7 +174,7 @@ Handle(BRepMesh_DiscretRoot) BRepMesh_DiscretFactory::Discret(
const Standard_Real theAngle)
{
Handle(BRepMesh_DiscretRoot) aDiscretRoot;
BRepMesh_PDiscretRoot anInstancePtr = NULL;
BRepMesh_DiscretRoot* anInstancePtr = NULL;
if (myPluginEntry != NULL)
{
// use plugin

111
src/BRepMesh/BRepMesh_Edge.hxx
View File

@ -19,28 +19,26 @@
#include <Standard_Macro.hxx>
#include <BRepMesh_DegreeOfFreedom.hxx>
//! Light weighted structure representing link of the mesh.
class BRepMesh_Edge
//! Light weighted structure representing simple link.
class BRepMesh_OrientedEdge
{
public:
DEFINE_STANDARD_ALLOC
//! Default constructor.
Standard_EXPORT BRepMesh_Edge()
: myFirstNode (-1),
myLastNode (-1),
myMovability(BRepMesh_Deleted)
Standard_EXPORT BRepMesh_OrientedEdge()
: myFirstNode(-1),
myLastNode(-1)
{
}
//! Contructs a link beetween two vertices.
Standard_EXPORT BRepMesh_Edge(const Standard_Integer theFirstNode,
const Standard_Integer theLastNode,
const BRepMesh_DegreeOfFreedom theMovability)
: myFirstNode (theFirstNode),
myLastNode (theLastNode),
myMovability(theMovability)
//! Constructs a link between two vertices.
Standard_EXPORT BRepMesh_OrientedEdge(
const Standard_Integer theFirstNode,
const Standard_Integer theLastNode)
: myFirstNode(theFirstNode),
myLastNode(theLastNode)
{
}
@ -55,49 +53,88 @@ public:
{
return myLastNode;
}
//! Returns hash code for this edge.
//! @param theUpper upper index in the container.
//! @return hash code.
Standard_EXPORT Standard_Integer HashCode(const Standard_Integer theUpper) const
{
return ::HashCode(myFirstNode + myLastNode, theUpper);
}
//! Checks this and other edge for equality.
//! @param theOther edge to be checked against this one.
//! @retrun TRUE if edges have the same orientation, FALSE if not.
inline Standard_Boolean IsEqual(const BRepMesh_OrientedEdge& theOther) const
{
return (myFirstNode == theOther.myFirstNode && myLastNode == theOther.myLastNode);
}
//! Alias for IsEqual.
Standard_Boolean operator ==(const BRepMesh_OrientedEdge& Other) const
{
return IsEqual(Other);
}
private:
Standard_Integer myFirstNode;
Standard_Integer myLastNode;
};
//! Light weighted structure representing link of the mesh.
class BRepMesh_Edge : public BRepMesh_OrientedEdge
{
public:
//! Default constructor.
Standard_EXPORT BRepMesh_Edge()
: BRepMesh_OrientedEdge(),
myMovability(BRepMesh_Deleted)
{
}
//! Constructs a link between two vertices.
Standard_EXPORT BRepMesh_Edge(
const Standard_Integer theFirstNode,
const Standard_Integer theLastNode,
const BRepMesh_DegreeOfFreedom theMovability)
: BRepMesh_OrientedEdge(theFirstNode, theLastNode),
myMovability(theMovability)
{
}
//! Returns movability flag of the Link.
inline BRepMesh_DegreeOfFreedom Movability() const
{
return myMovability;
}
//! Sets movability flag of the Link.
//! \param theMovability flag to be set.
inline void SetMovability(const BRepMesh_DegreeOfFreedom theMovability)
{
myMovability = theMovability;
}
//! Returns hash code for this edge.
//! \param theUpper upper index in the container.
//! \return hash code.
Standard_EXPORT Standard_Integer HashCode(const Standard_Integer theUpper) const
{
return ::HashCode(myFirstNode + myLastNode, theUpper);
}
//! Checks if the given edge and this one have the same orientation.
//! \param theOther edge to be checked against this one.
//! \retrun TRUE if edges have the same orientation, FALSE if not.
inline Standard_Boolean IsSameOrientation(const BRepMesh_Edge& theOther) const
{
return (myFirstNode == theOther.myFirstNode && myLastNode == theOther.myLastNode);
return BRepMesh_OrientedEdge::IsEqual(theOther);
}
//! Checks for equality with another edge.
//! \param theOther edge to be checked against this one.
//! \return TRUE if equal, FALSE if not.
inline Standard_Boolean IsEqual(const BRepMesh_Edge& theOther) const
{
if (myMovability == BRepMesh_Deleted ||
theOther.myMovability == BRepMesh_Deleted)
{
if (myMovability == BRepMesh_Deleted || theOther.myMovability == BRepMesh_Deleted)
return Standard_False;
}
return IsSameOrientation(theOther) ||
(myFirstNode == theOther.myLastNode && myLastNode == theOther.myFirstNode);
return IsSameOrientation(theOther) ||
(FirstNode() == theOther.LastNode() && LastNode() == theOther.FirstNode());
}
//! Alias for IsEqual.
@ -108,11 +145,15 @@ public:
private:
Standard_Integer myFirstNode;
Standard_Integer myLastNode;
BRepMesh_DegreeOfFreedom myMovability;
};
inline Standard_Integer HashCode(const BRepMesh_OrientedEdge& theEdge,
const Standard_Integer theUpper)
{
return theEdge.HashCode(theUpper);
}
inline Standard_Integer HashCode(const BRepMesh_Edge& theEdge,
const Standard_Integer theUpper)
{

89
src/BRepMesh/BRepMesh_EdgeParameterProvider.cxx Normal file
View File

@ -0,0 +1,89 @@
// Created on: 2014-08-13
// Created by: Oleg AGASHIN
// Copyright (c) 2011-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <BRepMesh_EdgeParameterProvider.hxx>
#include <gp_Pnt.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <BRep_Tool.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <Precision.hxx>
//=======================================================================
//function : Constructor
//purpose :
//=======================================================================
BRepMesh_EdgeParameterProvider::BRepMesh_EdgeParameterProvider(
const TopoDS_Edge& theEdge,
const TopoDS_Face& theFace,
const Handle(TColStd_HArray1OfReal)& theParameters)
: myParameters(theParameters),
myIsSameParam(BRep_Tool::SameParameter(theEdge)),
myScale(1.)
{
if (myIsSameParam)
return;
// Extract actual parametric values
Standard_Real aLastParam;
BRep_Tool::Range(theEdge, theFace, myFirstParam, aLastParam);
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);
}
BRepAdaptor_Curve aCOnS(theEdge, theFace);
myProjector.Initialize(aCOnS, aCOnS.FirstParameter(),
aCOnS.LastParameter(), Precision::PConfusion());
}
//=======================================================================
//function : Parameter
//purpose :
//=======================================================================
Standard_Real BRepMesh_EdgeParameterProvider::Parameter(
const Standard_Integer theIndex,
const gp_Pnt& thePoint3d)
{
if (myIsSameParam)
return myParameters->Value(theIndex);
// Use scaled
Standard_Real aPrevParam = myCurParam;
myCurParam = myFirstParam + myScale *
(myParameters->Value(theIndex) - myOldFirstParam);
myFoundParam += (myCurParam - aPrevParam);
myProjector.Perform(thePoint3d, myFoundParam);
if (myProjector.IsDone())
myFoundParam = myProjector.Point().Parameter();
return myFoundParam;
}

69
src/BRepMesh/BRepMesh_EdgeParameterProvider.hxx Normal file
View File

@ -0,0 +1,69 @@
// Created on: 2014-08-13
// Created by: Oleg AGASHIN
// Copyright (c) 2011-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _BRepMesh_EdgeParameterProvider_HeaderFile
#define _BRepMesh_EdgeParameterProvider_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Extrema_LocateExtPC.hxx>
#include <Handle_TColStd_HArray1OfReal.hxx>
class gp_Pnt;
class TopoDS_Edge;
class TopoDS_Face;
class TColStd_HArray1OfReal;
//! Auxiliary class provides correct parameters
//! on curve regarding SameParameter flag.
class BRepMesh_EdgeParameterProvider
{
public:
DEFINE_STANDARD_ALLOC
//! Constructor.
//! @param theEdge edge which parameters should be processed.
//! @param theFace face the parametric values are defined for.
//! @param theParameters parameters corresponded to discretization points.
BRepMesh_EdgeParameterProvider(
const TopoDS_Edge& theEdge,
const TopoDS_Face& theFace,
const Handle(TColStd_HArray1OfReal)& theParameters);
//! Returns parameter according to SameParameter flag of the edge.
//! If SameParameter is TRUE returns value from parameters w/o changes,
//! elsewhere scales initial parameter and tries to determine resulting
//! value using projection of the corresponded 3D point on PCurve.
Standard_Real Parameter(const Standard_Integer theIndex,
const gp_Pnt& thePoint3d);
private:
Handle(TColStd_HArray1OfReal) myParameters;
Standard_Boolean myIsSameParam;
Standard_Real myFirstParam;
Standard_Real myOldFirstParam;
Standard_Real myScale;
Standard_Real myCurParam;
Standard_Real myFoundParam;
Extrema_LocateExtPC myProjector;
};
#endif

59
src/BRepMesh/BRepMesh_EdgeTessellationExtractor.cxx Normal file
View File

@ -0,0 +1,59 @@
// Created on: 2014-08-13
// Created by: Oleg AGASHIN
// Copyright (c) 2011-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <BRepMesh_EdgeTessellationExtractor.hxx>
#include <Geom2d_Curve.hxx>
#include <Poly_PolygonOnTriangulation.hxx>
#include <Poly_Triangulation.hxx>
#include <BRepMesh_ShapeTool.hxx>
IMPLEMENT_STANDARD_HANDLE (BRepMesh_EdgeTessellationExtractor, BRepMesh_IEdgeTool)
IMPLEMENT_STANDARD_RTTIEXT(BRepMesh_EdgeTessellationExtractor, BRepMesh_IEdgeTool)
//=======================================================================
//function : Constructor
//purpose :
//=======================================================================
BRepMesh_EdgeTessellationExtractor::BRepMesh_EdgeTessellationExtractor(
const TopoDS_Edge& theEdge,
const Handle(Geom2d_Curve)& thePCurve,
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)
{
}
//=======================================================================
//function : Value
//purpose :
//=======================================================================
void BRepMesh_EdgeTessellationExtractor::Value(
const Standard_Integer theIndex,
Standard_Real& theParameter,
gp_Pnt& thePoint,
gp_Pnt2d& theUV)
{
const gp_Pnt& theRefPnt = myNodes(myIndices(theIndex));
thePoint = BRepMesh_ShapeTool::UseLocation(theRefPnt, myLoc);
theParameter = myProvider.Parameter(theIndex, thePoint);
theUV = myPCurve->Value(theParameter);
}

87
src/BRepMesh/BRepMesh_EdgeTessellationExtractor.hxx Normal file
View File

@ -0,0 +1,87 @@
// Created on: 2014-08-13
// Created by: Oleg AGASHIN
// Copyright (c) 2011-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _BRepMesh_EdgeTessellationExtractor_HeaderFile
#define _BRepMesh_EdgeTessellationExtractor_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <BRepMesh_IEdgeTool.hxx>
#include <BRepMesh_EdgeParameterProvider.hxx>
#include <Handle_Geom2d_Curve.hxx>
#include <Handle_Poly_PolygonOnTriangulation.hxx>
#include <Handle_Poly_Triangulation.hxx>
#include <TopLoc_Location.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColStd_Array1OfInteger.hxx>
class Poly_Triangulation;
class Poly_PolygonOnTriangulation;
class TopoDS_Edge;
class TopoDS_Face;
//! Auxiliary class implements functionality retrieving tessellated
//! representation of an edge stored in polygon.
class BRepMesh_EdgeTessellationExtractor : public BRepMesh_IEdgeTool
{
public:
//! Constructor.
//! Initializes extractor.
BRepMesh_EdgeTessellationExtractor(
const TopoDS_Edge& theEdge,
const Handle(Geom2d_Curve)& thePCurve,
const TopoDS_Face& theFace,
const Handle(Poly_Triangulation)& theTriangulation,
const Handle(Poly_PolygonOnTriangulation)& thePolygon,
const TopLoc_Location& theLocation);
//! Returns number of dicretization points.
virtual Standard_Integer NbPoints() const
{
return myIndices.Length();
}
//! Returns parameters of solution with the given index.
//! @param theIndex index of tessellation point.
//! @param theParameter parameters on PCurve corresponded to the solution.
//! @param thePoint tessellation point.
//! @param theUV coordinates of tessellation point in parametric space of face.
virtual void Value(const Standard_Integer theIndex,
Standard_Real& theParameter,
gp_Pnt& thePoint,
gp_Pnt2d& theUV);
DEFINE_STANDARD_RTTI(BRepMesh_EdgeTessellationExtractor)
private:
//! Assignment operator.
void operator =(const BRepMesh_EdgeTessellationExtractor& /*theOther*/)
{
}
private:
BRepMesh_EdgeParameterProvider myProvider;
const Handle(Geom2d_Curve)& myPCurve;
const TColgp_Array1OfPnt& myNodes;
const TColStd_Array1OfInteger& myIndices;
const TopLoc_Location myLoc;
};
DEFINE_STANDARD_HANDLE(BRepMesh_EdgeTessellationExtractor, BRepMesh_IEdgeTool)
#endif

217
src/BRepMesh/BRepMesh_EdgeTessellator.cxx Normal file
View File

@ -0,0 +1,217 @@
// Created on: 2014-08-13
// Created by: Oleg AGASHIN
// Copyright (c) 2011-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <BRepMesh_EdgeTessellator.hxx>
#include <Geom_Surface.hxx>
#include <Geom_Plane.hxx>
#include <Geom2d_Curve.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
#include <BRepAdaptor_HSurface.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <TopLoc_Location.hxx>
#include <BRep_Tool.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <TopExp_Explorer.hxx>
#include <TopoDS_Vertex.hxx>
#include <TopoDS.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TColStd_Array1OfReal.hxx>
IMPLEMENT_STANDARD_HANDLE (BRepMesh_EdgeTessellator, BRepMesh_IEdgeTool)
IMPLEMENT_STANDARD_RTTIEXT(BRepMesh_EdgeTessellator, BRepMesh_IEdgeTool)
//=======================================================================
//function : Constructor
//purpose :
//=======================================================================
BRepMesh_EdgeTessellator::BRepMesh_EdgeTessellator(
const TopoDS_Edge& theEdge,
const Handle(BRepMesh_FaceAttribute)& theFaceAttribute,
const TopTools_IndexedDataMapOfShapeListOfShape& theMapOfSharedFaces,
const Standard_Real theLinDeflection,
const Standard_Real theAngDeflection)
: mySurface(theFaceAttribute->Surface())
{
Standard_Real aPreciseAngDef = 0.5 * theAngDeflection;
Standard_Real aPreciseLinDef = 0.5 * theLinDeflection;
if (theEdge.Orientation() == TopAbs_INTERNAL)
aPreciseLinDef *= 0.5;
mySquareEdgeDef = aPreciseLinDef * aPreciseLinDef;
Standard_Boolean isSameParam = BRep_Tool::SameParameter(theEdge);
if (isSameParam)
myCOnS.Initialize(theEdge);
else
myCOnS.Initialize(theEdge, theFaceAttribute->Face());
TopLoc_Location aLoc;
const GeomAbs_CurveType aCurveType = myCOnS.GetType();
Standard_Integer aMinPntNb = (aCurveType == GeomAbs_Circle) ? 4 : 2; //OCC287
// Get range on 2d curve
Standard_Real aFirstParam, aLastParam;
BRep_Tool::Range(theEdge, theFaceAttribute->Face(), aFirstParam, aLastParam);
myTool = new BRepMesh_GeomTool(myCOnS, aFirstParam, aLastParam,
aPreciseLinDef, aPreciseAngDef, aMinPntNb);
if (aCurveType == GeomAbs_BSplineCurve)
{
// TODO: remove this code block when #24959 is fixed
const Standard_Integer aNbInt = myCOnS.NbIntervals(GeomAbs_C1);
if ( aNbInt > 0 )
{
TColStd_Array1OfReal anIntervals( 1, aNbInt + 1 );
myCOnS.Intervals(anIntervals, GeomAbs_C1);
for (Standard_Integer aIntIt = 1; aIntIt <= aNbInt; ++aIntIt)
{
const Standard_Real& aStartInt = anIntervals.Value( aIntIt );
const Standard_Real& anEndInt = anIntervals.Value( aIntIt + 1 );
BRepMesh_GeomTool aDetalizator(myCOnS, aStartInt, anEndInt,
aPreciseLinDef, aPreciseAngDef, aMinPntNb);
Standard_Integer aNbAddNodes = aDetalizator.NbPoints();
for ( Standard_Integer aNodeIt = 1; aNodeIt <= aNbAddNodes; ++aNodeIt )
{
Standard_Real aParam;
gp_Pnt aPoint3d;
gp_Pnt2d aPoint2d;
aDetalizator.Value( aNodeIt, mySurface, aParam, aPoint3d, aPoint2d );
myTool->AddPoint( aPoint3d, aParam, Standard_False );
}
}
}
}
// PTv, chl/922/G9, Take into account internal vertices
// it is necessary for internal edges, which do not split other edges, by their vertex
TopExp_Explorer aVertexIt(theEdge, TopAbs_VERTEX);
for (; aVertexIt.More(); aVertexIt.Next())
{
const TopoDS_Vertex& aVertex = TopoDS::Vertex(aVertexIt.Current());
if (aVertex.Orientation() != TopAbs_INTERNAL)
continue;
myTool->AddPoint(BRep_Tool::Pnt(aVertex),
BRep_Tool::Parameter(aVertex, theEdge), Standard_True);
}
Standard_Integer aNodesNb = myTool->NbPoints();
//Check deflection in 2d space for improvement of edge tesselation.
if( isSameParam && aNodesNb > 1)
{
const TopTools_ListOfShape& aSharedFaces = theMapOfSharedFaces.FindFromKey(theEdge);
TopTools_ListIteratorOfListOfShape aFaceIt(aSharedFaces);
for (; aFaceIt.More(); aFaceIt.Next())
{
TopLoc_Location aLoc;
const TopoDS_Face& aFace = TopoDS::Face(aFaceIt.Value());
Handle(Geom_Surface) aSurf = BRep_Tool::Surface(aFace, aLoc);
if (aSurf->IsInstance(STANDARD_TYPE(Geom_Plane)))
continue;
Standard_Real aF, aL;
Handle(Geom2d_Curve) aCurve2d = BRep_Tool::CurveOnSurface(theEdge, aFace, aF, aL);
if ( Abs(aF - aFirstParam) > Precision::PConfusion() ||
Abs(aL - aLastParam ) > Precision::PConfusion() )
{
continue;
}
aNodesNb = myTool->NbPoints();
TColStd_Array1OfReal aParamArray(1, aNodesNb);
for (Standard_Integer i = 1; i <= aNodesNb; ++i)
{
gp_Pnt2d aTmpUV;
gp_Pnt aTmpPnt;
Standard_Real aParam;
myTool->Value(i, mySurface, aParam, aTmpPnt, aTmpUV);
aParamArray.SetValue(i, aParam);
}
for (Standard_Integer i = 1; i < aNodesNb; ++i)
splitSegment(aSurf, aCurve2d, aParamArray(i), aParamArray(i + 1), 1);
}
}
}
//=======================================================================
//function : Value
//purpose :
//=======================================================================
void BRepMesh_EdgeTessellator::Value(const Standard_Integer theIndex,
Standard_Real& theParameter,
gp_Pnt& thePoint,
gp_Pnt2d& theUV)
{
myTool->Value(theIndex, mySurface, theParameter, thePoint, theUV);
}
//=======================================================================
//function : splitSegment
//purpose :
//=======================================================================
void BRepMesh_EdgeTessellator::splitSegment(
const Handle(Geom_Surface)& theSurf,
const Handle(Geom2d_Curve)& theCurve2d,
const Standard_Real theFirst,
const Standard_Real theLast,
const Standard_Integer theNbIter)
{
// limit iteration depth
if(theNbIter > 10)
return;
gp_Pnt2d uvf, uvl, uvm;
gp_Pnt P3dF, P3dL, midP3d, midP3dFromSurf;
Standard_Real midpar;
if(Abs(theLast - theFirst) < 2 * Precision::PConfusion())
return;
theCurve2d->D0(theFirst, uvf);
theCurve2d->D0(theLast, uvl);
P3dF = theSurf->Value(uvf.X(), uvf.Y());
P3dL = theSurf->Value(uvl.X(), uvl.Y());
if(P3dF.SquareDistance(P3dL) < mySquareEdgeDef)
return;
uvm = gp_Pnt2d((uvf.XY() + uvl.XY())*0.5);
midP3dFromSurf = theSurf->Value(uvm.X(), uvm.Y());
gp_XYZ aVec = P3dL.XYZ() - P3dF.XYZ();
aVec.Normalize();
gp_XYZ Vec1 = midP3dFromSurf.XYZ() - P3dF.XYZ();
Standard_Real aModulus = Vec1.Dot(aVec);
gp_XYZ aProj = aVec * aModulus;
gp_XYZ aDist = Vec1 - aProj;
if(aDist.SquareModulus() < mySquareEdgeDef)
return;
midpar = (theFirst + theLast) * 0.5;
myCOnS.D0(midpar, midP3d);
myTool->AddPoint(midP3d, midpar, Standard_False);
splitSegment(theSurf, theCurve2d, theFirst, midpar, theNbIter + 1);
splitSegment(theSurf, theCurve2d, midpar, theLast, theNbIter + 1);
}

88
src/BRepMesh/BRepMesh_EdgeTessellator.hxx Normal file
View File

@ -0,0 +1,88 @@
// Created on: 2014-08-13
// Created by: Oleg AGASHIN
// Copyright (c) 2011-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _BRepMesh_EdgeTessellator_HeaderFile
#define _BRepMesh_EdgeTessellator_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <BRepMesh_Collections.hxx>
#include <BRepMesh_IEdgeTool.hxx>
#include <BRepMesh_GeomTool.hxx>
#include <BRepMesh_FaceAttribute.hxx>
#include <Handle_Geom_Surface.hxx>
#include <Handle_Geom2d_Curve.hxx>
#include <Handle_BRepAdaptor_HSurface.hxx>
#include <BRepAdaptor_Curve.hxx>
class Geom_Surface;
class Geom2d_Curve;
class TopoDS_Edge;
class BRepAdaptor_HSurface;
class TopTools_IndexedDataMapOfShapeListOfShape;
//! Auxiliary class implements functionality producing tessellated
//! representation of an edge based on edge geometry.
class BRepMesh_EdgeTessellator : public BRepMesh_IEdgeTool
{
public:
//! Constructor.
//! Automatically performs tessellation of the edge according to the
//! given parameters.
BRepMesh_EdgeTessellator(
const TopoDS_Edge& theEdge,
const Handle(BRepMesh_FaceAttribute)& theFaceAttribute,
const TopTools_IndexedDataMapOfShapeListOfShape& theMapOfSharedFaces,
const Standard_Real theLinDeflection,
const Standard_Real theAngDeflection);
//! Returns number of dicretization points.
virtual Standard_Integer NbPoints() const
{
return myTool->NbPoints();
}
//! Returns parameters of solution with the given index.
//! @param theIndex index of tessellation point.
//! @param theParameter parameters on PCurve corresponded to the solution.
//! @param thePoint tessellation point.
//! @param theUV coordinates of tessellation point in parametric space of face.
virtual void Value(const Standard_Integer theIndex,
Standard_Real& theParameter,
gp_Pnt& thePoint,
gp_Pnt2d& theUV);
DEFINE_STANDARD_RTTI(BRepMesh_EdgeTessellator)
private:
//!
void splitSegment(const Handle(Geom_Surface)& theSurf,
const Handle(Geom2d_Curve)& theCurve2d,
const Standard_Real theFirst,
const Standard_Real theLast,
const Standard_Integer theNbIter);
private:
N_HANDLE<BRepMesh_GeomTool> myTool;
Handle(BRepAdaptor_HSurface) mySurface;
BRepAdaptor_Curve myCOnS;
Standard_Real mySquareEdgeDef;
};
DEFINE_STANDARD_HANDLE(BRepMesh_EdgeTessellator, BRepMesh_IEdgeTool)
#endif

146
src/BRepMesh/BRepMesh_FaceAttribute.cxx
View File

@ -13,16 +13,154 @@
// commercial license or contractual agreement.
#include <BRepMesh_FaceAttribute.hxx>
#include <TopoDS_Vertex.hxx>
#include <BRepAdaptor_HSurface.hxx>
#include <BRepMesh_ShapeTool.hxx>
#include <BRepMesh_Classifier.hxx>
#include <BRepTools.hxx>
IMPLEMENT_STANDARD_HANDLE (BRepMesh_FaceAttribute, Standard_Transient)
IMPLEMENT_STANDARD_RTTIEXT(BRepMesh_FaceAttribute, Standard_Transient)
//=======================================================================
//function : BRepMesh_FaceAttribute
//function : Constructor
//purpose :
//=======================================================================
BRepMesh_FaceAttribute::BRepMesh_FaceAttribute():
mydefface(0.), myumin(0.), myumax(0.), myvmin(0.), myvmax(0.),
mydeltaX(1.), mydeltaY(1.), myminX(0.), myminY(0.)
BRepMesh_FaceAttribute::BRepMesh_FaceAttribute(
const TopoDS_Face& theFace,
BRepMeshCol::DMapOfVertexInteger& theBoundaryVertices,
BRepMeshCol::DMapOfIntegerPnt& theBoundaryPoints)
: myDefFace (0.),
myUMin (0.),
myUMax (0.),
myVMin (0.),
myVMax (0.),
myDeltaX (1.),
myDeltaY (1.),
myStatus (BRepMesh_NoError),
myBoundaryVertices(theBoundaryVertices),
myBoundaryPoints (theBoundaryPoints),
myAllocator (new NCollection_IncAllocator(64000))
{
myVertexEdgeMap = new BRepMeshCol::IMapOfInteger;
myInternalEdges = new BRepMeshCol::DMapOfShapePairOfPolygon;
mySurfacePoints = new BRepMeshCol::DMapOfIntegerPnt;
myClassifier = new BRepMesh_Classifier;
myFace = theFace;
BRepTools::Update(myFace);
myFace.Orientation(TopAbs_FORWARD);
BRepAdaptor_Surface aSurfAdaptor(myFace, Standard_False);
mySurface = new BRepAdaptor_HSurface(aSurfAdaptor);
ResetStructure();
}
//=======================================================================
//function : Destructor
//purpose :
//=======================================================================
BRepMesh_FaceAttribute::~BRepMesh_FaceAttribute()
{
clearLocal();
mySurfaceVertices.Clear();
mySurfacePoints->Clear();
myClassifier.Nullify();
myAllocator.Nullify();
}
//=======================================================================
//function : clearLocal
//purpose :
//=======================================================================
void BRepMesh_FaceAttribute::clearLocal()
{
myStructure.Nullify();
myLocation2D.Clear();
myVertexEdgeMap->Clear();
myInternalEdges->Clear();
myAllocator->Reset(Standard_False);
}
//=======================================================================
//function : ResetStructure
//purpose :
//=======================================================================
Handle(BRepMesh_DataStructureOfDelaun)& BRepMesh_FaceAttribute::ResetStructure()
{
clearLocal();
myStructure = new BRepMesh_DataStructureOfDelaun(myAllocator);
BRepTools::UVBounds(myFace, myUMin, myUMax, myVMin, myVMax);
Standard_Real aTolU = ToleranceU();
Standard_Real aTolV = ToleranceV();
myStructure->Data().SetCellSize(14.0 * aTolU, 14.0 * aTolV);
myStructure->Data().SetTolerance(aTolU, aTolV);
return myStructure;
}
//=======================================================================
//function : computeParametricTolerance
//purpose :
//=======================================================================
Standard_Real BRepMesh_FaceAttribute::computeParametricTolerance(
const Standard_Real theFirstParam,
const Standard_Real theLastParam) const
{
const Standard_Real aDeflectionUV = 1.e-05;
return Max(Precision::PConfusion(), (theLastParam - theFirstParam) * aDeflectionUV);
}
//=======================================================================
//function : getVertexIndex
//purpose :
//=======================================================================
Standard_Boolean BRepMesh_FaceAttribute::getVertexIndex(
const TopoDS_Vertex& theVertex,
Standard_Integer& theVertexIndex) const
{
if (myBoundaryVertices.IsBound(theVertex))
theVertexIndex = myBoundaryVertices.Find(theVertex);
else if (mySurfaceVertices.IsBound(theVertex))
theVertexIndex = mySurfaceVertices.Find(theVertex);
else
return Standard_False;
return Standard_True;
}
//=======================================================================
//function : AddNode
//purpose :
//=======================================================================
void BRepMesh_FaceAttribute::AddNode(
const Standard_Integer theIndex,
const gp_XY& theUV,
const BRepMesh_DegreeOfFreedom theMovability,
Standard_Integer& theNodeIndex,
Standard_Integer& theNodeOnEdgeIndex)
{
BRepMesh_Vertex aNode(theUV, theIndex, theMovability);
theNodeIndex = myStructure->AddNode(aNode);
theNodeOnEdgeIndex = myVertexEdgeMap->FindIndex(theNodeIndex);
if (theNodeOnEdgeIndex == 0)
theNodeOnEdgeIndex = myVertexEdgeMap->Add(theNodeIndex);
}
//=======================================================================
//function : Scale
//purpose :
//=======================================================================
gp_XY BRepMesh_FaceAttribute::Scale(const gp_XY& thePoint2d,
const Standard_Boolean isToFaceBasis)
{
return isToFaceBasis ?
gp_XY((thePoint2d.X() - myUMin) / myDeltaX, (thePoint2d.Y() - myVMin) / myDeltaY) :
gp_XY(thePoint2d.X() * myDeltaX + myUMin, thePoint2d.Y() * myDeltaY + myVMin);
}

388
src/BRepMesh/BRepMesh_FaceAttribute.hxx
View File

@ -15,83 +15,341 @@
#define _BRepMesh_FaceAttribute_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineHandle.hxx>
#include <BRepMesh_Collections.hxx>
#include <Standard_Transient.hxx>
#include <Standard_DefineHandle.hxx>
#include <BRepMesh_Status.hxx>
#include <BRepMesh_Collections.hxx>
#include <BRepMesh_DataStructureOfDelaun.hxx>
#include <Handle_BRepAdaptor_HSurface.hxx>
//! auxiliary class for FastDiscret and FastDiscretFace classes <br>
class BRepAdaptor_HSurface;
//! Auxiliary class for FastDiscret and FastDiscretFace classes.
class BRepMesh_FaceAttribute : public Standard_Transient
{
public:
Standard_EXPORT BRepMesh_FaceAttribute();
//! Constructor.
//! @param theFace face the attribute is created for.
//! Used for default initialization. Attribute keeps reference
//! to the source face with forward orientation.
//! @param theBoundaryVertices shared map of shape vertices.
//! @param theBoundaryPoints shared discretization points of shape boundaries.
Standard_EXPORT BRepMesh_FaceAttribute(
const TopoDS_Face& theFace,
BRepMeshCol::DMapOfVertexInteger& theBoundaryVertices,
BRepMeshCol::DMapOfIntegerPnt& theBoundaryPoints);
//! Destructor.
virtual ~BRepMesh_FaceAttribute();
public: //! @name main geometrical properties.
//! Returns face's surface.
inline const Handle(BRepAdaptor_HSurface)& Surface() const
{
return mySurface;
}
//! Returns forward oriented face to be used for calculations.
inline const TopoDS_Face& Face() const
{
return myFace;
}
//! Returns U tolerance of face calculated regarding its parameters.
inline Standard_Real ToleranceU() const
{
return computeParametricTolerance(myUMin, myUMax);
}
//! Returns V tolerance of face calculated regarding its parameters.
inline Standard_Real ToleranceV() const
{
return computeParametricTolerance(myVMin, myVMax);
}
//! Gives face deflection parameter.
inline Standard_Real GetDefFace() const
{
return myDefFace;
}
//! Sets face deflection.
inline void SetDefFace(const Standard_Real theDefFace)
{
myDefFace = theDefFace;
}
//! Gives minimal value in U domain.
inline Standard_Real GetUMin() const
{
return myUMin;
}
//! Sets minimal value in U domain.
inline void SetUMin(const Standard_Real theUMin)
{
myUMin = theUMin;
}
//! Gives minimal value in V domain.
inline Standard_Real GetVMin() const
{
return myVMin;
}
//! Sets minimal value in V domain.
inline void SetVMin(const Standard_Real theVMin)
{
myVMin = theVMin;
}
//! Gives maximal value in U domain.
inline Standard_Real GetUMax() const
{
return myUMax;
}
//! Sets maximal value in U domain.
inline void SetUMax(const Standard_Real theUMax)
{
myUMax = theUMax;
}
//! Gives maximal value in V domain.
inline Standard_Real GetVMax() const
{
return myVMax;
}
//! Sets maximal value in V domain.
inline void SetVMax(const Standard_Real theVMax)
{
myVMax = theVMax;
}
//! Gives value of step in U domain.
inline Standard_Real GetDeltaX() const
{
return myDeltaX;
}
//! Sets value of step in U domain.
inline void SetDeltaX(const Standard_Real theDeltaX)
{
myDeltaX = theDeltaX;
}
//! Gives value of step in V domain.
inline Standard_Real GetDeltaY() const
{
return myDeltaY;
}
//! Sets value of step in V domain.
inline void SetDeltaY(const Standard_Real theDeltaY)
{
myDeltaY = theDeltaY;
}
//! Sets set of status flags for this face.
inline Standard_Integer GetStatus() const
{
return myStatus;
}
//! Sets status flag for this face.
inline void SetStatus(const BRepMesh_Status theStatus)
{
myStatus |= theStatus;
}
//! Returns TRUE in case if computed data is valid.
inline Standard_Boolean IsValid() const
{
return (myStatus == BRepMesh_NoError || myStatus == BRepMesh_ReMesh);
}
public: //! @name auxiliary structures
//! Clear all face attribute.
Standard_EXPORT void Clear();
//! Resets mesh data structure.
//! @returns reset data structure.
Standard_EXPORT Handle(BRepMesh_DataStructureOfDelaun)& ResetStructure();
//! Gives reference to map of internal edges of face.
inline BRepMeshCol::HDMapOfShapePairOfPolygon& ChangeInternalEdges()
{
return myInternalEdges;
}
//! Gives reference to map of 2D points of discretization.
inline BRepMeshCol::DMapOfIntegerListOfXY& ChangeLocation2D()
{
return myLocation2D;
}
//! Gives reference to map of 3D points of discretization.
inline BRepMeshCol::HDMapOfIntegerPnt& ChangeSurfacePoints()
{
return mySurfacePoints;
}
//! Gives reference on map of (vertex, edge) pairs of face.
inline BRepMeshCol::HIMapOfInteger& ChangeVertexEdgeMap()
{
return myVertexEdgeMap;
}
//! Gives Delaunay data structure.
inline Handle(BRepMesh_DataStructureOfDelaun)& ChangeStructure()
{
return myStructure;
}
//! Returns classifier.
inline BRepMeshCol::HClassifier& ChangeClassifier()
{
return myClassifier;
}
public: //! @name Point/Vertex/Node manipulators
//! Gives the number of different locations in 3D space.
inline Standard_Integer LastPointId() const
{
return myBoundaryPoints.Extent() + mySurfacePoints->Extent();
}
//! Gives the 3D location of the vertex.
inline const gp_Pnt& GetPoint(const BRepMesh_Vertex& theVertex) const
{
return GetPoint(theVertex.Location3d());
}
//! Gives the 3D location of the vertex.
inline const gp_Pnt& GetPoint(const Standard_Integer theIndex) const
{
if (theIndex > myBoundaryPoints.Extent())
return mySurfacePoints->Find(theIndex);
return myBoundaryPoints(theIndex);
}
//! Returns index of the given vertex if it exists in cache,
//! elsewhere adds it to cache and returns cached index.
//! @param theVertexExplorer template parameter intended to transfer
//! parameters of vertex to method. Explorer class can implement different
//! approaches of extraction of target parameters.
//! @param isFillEdgeVertices if TRUE adds vertex to shared map of
//! edges vertices, elsewhere adds it map of face vertices.
template<class HVertexExplorer>
Standard_Integer GetVertexIndex(
const HVertexExplorer& theVertexExplorer,
const Standard_Boolean isFillEdgeVertices = Standard_False)
{
const TopoDS_Vertex& aVertex = theVertexExplorer->Vertex();
Standard_Integer aNewVertexIndex = 0;
if (getVertexIndex(aVertex, aNewVertexIndex))
return aNewVertexIndex;
if (!theVertexExplorer->IsSameUV() ||
!getVertexIndex(theVertexExplorer->SameVertex(), aNewVertexIndex))
{
aNewVertexIndex = LastPointId() + 1;
BRepMeshCol::DMapOfIntegerPnt& aPointsMap = isFillEdgeVertices ?
myBoundaryPoints : *mySurfacePoints;
aPointsMap.Bind(aNewVertexIndex, theVertexExplorer->Point());
}
BRepMeshCol::DMapOfVertexInteger& aVertexMap = isFillEdgeVertices ?
myBoundaryVertices : mySurfaceVertices;
aVertexMap.Bind(aVertex, aNewVertexIndex);
return aNewVertexIndex;
}
//! Adds node with the given parameters to mesh.
//! @param theIndex index of 3D point corresponded to the node.
//! @param theUV node position.
//! @param theMovability movability of a node.
//! @param theNodeIndex index of vertex in mesh structure.
//! @param theNodeOnEdgeIndex ordered index of node on the boundary.
Standard_EXPORT void AddNode(const Standard_Integer theIndex,
const gp_XY& theUV,
const BRepMesh_DegreeOfFreedom theMovability,
Standard_Integer& theNodeIndex,
Standard_Integer& theNodeOnEdgeIndex);
public: //! @name Auxiliary methods
inline Standard_Real& GetDefFace()
{
return mydefface;
}
inline Standard_Real& GetUMin()
{
return myumin;
}
inline Standard_Real& GetVMin()
{
return myvmin;
}
inline Standard_Real& GetUMax()
{
return myumax;
}
inline Standard_Real& GetVMax()
{
return myvmax;
}
inline Standard_Real& GetDeltaX()
{
return mydeltaX;
}
inline Standard_Real& GetDeltaY()
{
return mydeltaY;
}
inline Standard_Real& GetMinX()
{
return myminX;
}
inline Standard_Real& GetMinY()
{
return myminY;
}
inline BRepMeshCol::HClassifier& GetClassifier()
{
return myclassifier;
}
//! Scales the given point from real parametric space
//! to face basis and otherwise.
//! @param thePoint2d point to be scaled.
//! @param isToFaceBasis if TRUE converts point to face basis,
//! otherwise performs reverse conversion.
//! @return scaled point.
Standard_EXPORT gp_XY Scale(const gp_XY& thePoint2d,
const Standard_Boolean isToFaceBasis);
DEFINE_STANDARD_RTTI(BRepMesh_FaceAttribute)
private:
private:
Standard_Real mydefface;
Standard_Real myumin;
Standard_Real myumax;
Standard_Real myvmin;
Standard_Real myvmax;
Standard_Real mydeltaX;
Standard_Real mydeltaY;
Standard_Real myminX;
Standard_Real myminY;
BRepMeshCol::HClassifier myclassifier;
//! Assignment operator.
void operator =(const BRepMesh_FaceAttribute& /*theOther*/)
{
}
//! Computes parametric tolerance of a face regarding the given limits.
Standard_Real computeParametricTolerance(
const Standard_Real theFirstParam,
const Standard_Real theLastParam) const;
//! Clears internal data structures local to face.
void clearLocal();
//! Returns index of the given vertex if it exists in cache.
//! @param theVertex vertex which index should be retrieved.
//! @param theVertexIndex index of the given vertex.
//! @return TRUE if cached value is found, FALSE elsewhere.
Standard_EXPORT Standard_Boolean getVertexIndex(
const TopoDS_Vertex& theVertex,
Standard_Integer& theVertexIndex) const;
private:
Standard_Real myDefFace; //!< Restore face deflection
Standard_Real myUMin; //!< Describes minimal value in U domain
Standard_Real myUMax; //!< Describes maximal value in U domain
Standard_Real myVMin; //!< Describes minimal value in V domain
Standard_Real myVMax; //!< Describes maximal value in V domain
Standard_Real myDeltaX;
Standard_Real myDeltaY;
Standard_Integer myStatus;
BRepMeshCol::DMapOfVertexInteger& myBoundaryVertices;
BRepMeshCol::DMapOfIntegerPnt& myBoundaryPoints;
TopoDS_Face myFace;
Handle(BRepAdaptor_HSurface) mySurface;
BRepMeshCol::DMapOfVertexInteger mySurfaceVertices;
BRepMeshCol::HDMapOfIntegerPnt mySurfacePoints;
BRepMeshCol::DMapOfIntegerListOfXY myLocation2D;
BRepMeshCol::HIMapOfInteger myVertexEdgeMap;
BRepMeshCol::HDMapOfShapePairOfPolygon myInternalEdges;
Handle(BRepMesh_DataStructureOfDelaun) myStructure;
BRepMeshCol::HClassifier myClassifier;
BRepMeshCol::Allocator myAllocator;
};
DEFINE_STANDARD_HANDLE(BRepMesh_FaceAttribute, Standard_Transient)

2193
src/BRepMesh/BRepMesh_FastDiscret.cxx
View File

File diff suppressed because it is too large Load Diff

373
src/BRepMesh/BRepMesh_FastDiscret.hxx
View File

@ -31,16 +31,19 @@
#include <BRepMesh_Triangle.hxx>
#include <BRepMesh_FaceAttribute.hxx>
#include <BRepMesh_Collections.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <BRep_Tool.hxx>
#include <BRepMesh_ShapeTool.hxx>
#include <TopoDS_Vertex.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
class BRepMesh_DataStructureOfDelaun;
class Bnd_Box;
class TopoDS_Shape;
class TopoDS_Face;
class TopTools_IndexedDataMapOfShapeListOfShape;
class TopoDS_Edge;
class BRepAdaptor_HSurface;
class Geom2d_Curve;
class TopoDS_Vertex;
class BRepMesh_Edge;
class BRepMesh_Vertex;
class gp_Pnt;
@ -86,16 +89,17 @@ public:
const Standard_Boolean shapetrigu = Standard_False,
const Standard_Boolean isInParallel = Standard_False);
//! Build triangulation on the whole shape <br>
//! Build triangulation on the whole shape.
Standard_EXPORT void Perform(const TopoDS_Shape& shape);
//! Record a face for further processing. <br>
Standard_EXPORT void Add(const TopoDS_Face& face,
const TopTools_IndexedDataMapOfShapeListOfShape& ancestor) ;
//! Record a face for further processing.
//! @return status flags collected during discretization
//! of boundaries of the given face.
Standard_EXPORT Standard_Integer Add(const TopoDS_Face& face);
//! Triangulate a face previously recorded for <br>
//! processing by call to Add(). Can be executed in <br>
//! parallel threads. <br>
//! Triangulate a face previously recorded for
//! processing by call to Add(). Can be executed in
//! parallel threads.
Standard_EXPORT void Process(const TopoDS_Face& face) const;
void operator ()(const TopoDS_Face& face) const
@ -103,82 +107,22 @@ public:
Process(face);
}
Standard_EXPORT BRepMesh_Status CurrentFaceStatus() const;
//! Request algorithm to launch in multiple threads <br>
//! to improve performance (should be supported by plugin). <br>
Standard_EXPORT void SetParallel(const Standard_Boolean theInParallel);
inline void SetParallel(const Standard_Boolean theInParallel)
{
myInParallel = theInParallel;
}
//! Returns the multi-threading usage flag. <br>
Standard_EXPORT Standard_Boolean IsParallel() const;
//! Creates mutexes for each sub-shape of type theType in theShape. <br>
//! Used to avoid data races. <br>
Standard_EXPORT void CreateMutexesForSubShapes(const TopoDS_Shape& theShape,
const TopAbs_ShapeEnum theType);
//! Removes all created mutexes <br>
Standard_EXPORT void RemoveAllMutexes();
//! Gives the number of built triangles. <br>
Standard_EXPORT Standard_Integer NbTriangles() const;
//! Gives the triangle of <Index>. <br>
Standard_EXPORT const BRepMesh_Triangle& Triangle(const Standard_Integer Index) const;
//! Gives the number of built Edges <br>
Standard_EXPORT Standard_Integer NbEdges() const;
//! Gives the edge of index <Index>. <br>
Standard_EXPORT const BRepMesh_Edge& Edge(const Standard_Integer Index) const;
//! Gives the number of built Vertices. <br>
Standard_EXPORT Standard_Integer NbVertices() const;
//! Gives the vertex of <Index>. <br>
Standard_EXPORT const BRepMesh_Vertex& Vertex(const Standard_Integer Index) const;
//! Gives the nodes of triangle with the given index.
Standard_EXPORT void TriangleNodes(const Standard_Integer theIndex,
Standard_Integer (&theNodes)[3]) const
inline Standard_Boolean IsParallel() const
{
myStructure->ElementNodes(Triangle(theIndex), theNodes);
return myInParallel;
}
//! Gives the location3d of the vertex of <Index>. <br>
Standard_EXPORT const gp_Pnt& Pnt(const Standard_Integer Index) const;
//! Gives the list of indices of the vertices <br>
Standard_EXPORT void VerticesOfDomain(BRepMeshCol::MapOfInteger& Indices) const;
//! Gives the list of indices of the edges <br>
inline void EdgesOfDomain(BRepMeshCol::MapOfInteger& Indices) const
{
Indices = myStructure->LinksOfDomain();
}
//! Gives the list of indices of the triangles <br>
inline void TrianglesOfDomain(BRepMeshCol::MapOfInteger& Indices) const
{
Indices = myStructure->ElementsOfDomain();
}
//! Gives the number of different location in 3d space.
//! It is different of the number of vertices if there
//! is more than one surface. <br>
//! Even for one surface, the number can be different
//! if an edge is shared. <br>
inline Standard_Integer NbPoint3d() const
{
return myNbLocat;
}
//! Gives the 3d space location of the vertex <Index>. <br>
inline const gp_Pnt& Point3d(const Standard_Integer Index) const
{
return myLocation3d(Index);
}
//! returns the deflection value. <br>
inline Standard_Real GetDeflection() const
{
@ -206,82 +150,227 @@ public:
return myShapetrigu;
}
//! returns the face deflection value. <br>
Standard_EXPORT Standard_Boolean GetFaceAttribute(const TopoDS_Face& face,Handle(BRepMesh_FaceAttribute)& fattrib) const;
Standard_EXPORT void InitSharedFaces(const TopoDS_Shape& theShape);
//! remove face attribute as useless to free locate memory <br>
Standard_EXPORT void RemoveFaceAttribute(const TopoDS_Face& face);
inline const TopTools_DataMapOfShapeReal& GetMapOfDefEdge() const
inline const TopTools_IndexedDataMapOfShapeListOfShape& SharedFaces() const
{
return myMapdefle;
return mySharedFaces;
}
//! Gives face attribute.
Standard_EXPORT Standard_Boolean GetFaceAttribute
( const TopoDS_Face& theFace, Handle(BRepMesh_FaceAttribute)& theAttribute ) const;
//! Remove face attribute as useless to free locate memory.
Standard_EXPORT void RemoveFaceAttribute( const TopoDS_Face& theFace );
//! Returns number of boundary 3d points.
inline Standard_Integer NbBoundaryPoints() const
{
return myBoundaryPoints.Extent();
}
DEFINE_STANDARD_RTTI(BRepMesh_FastDiscret)
private:
void Add(const TopoDS_Edge& edge,
const TopoDS_Face& face,
const Handle(BRepAdaptor_HSurface)& S,
const Handle(Geom2d_Curve)& C,
const TopTools_IndexedDataMapOfShapeListOfShape& ancestor,
const Standard_Real defedge,
const Standard_Real first,
const Standard_Real last);
void Add(const TopoDS_Vertex& theVert,
const TopoDS_Face& face,
const Handle(BRepAdaptor_HSurface)& S);
Standard_Boolean Update(const TopoDS_Edge& Edge,
const TopoDS_Face& Face,
const Handle(Geom2d_Curve)& C,
const Standard_Real defedge,
const Standard_Real first,
const Standard_Real last);
void InternalVertices(const Handle(BRepAdaptor_HSurface)& caro,
BRepMeshCol::ListOfVertex& inter,
const Standard_Real defedge,
const BRepMeshCol::HClassifier& classifier);
Standard_Real Control(const Handle(BRepAdaptor_HSurface)& caro,
const Standard_Real defface,
BRepMeshCol::ListOfVertex& inter,
BRepMeshCol::ListOfInteger& badTri,
BRepMeshCol::ListOfInteger& nulTri,
BRepMesh_Delaun& trigu,
const Standard_Boolean isfirst);
void AddInShape(const TopoDS_Face& face,
const Standard_Real defedge);
private:
//! Auxiliary class used to extract geometrical parameters of TopoDS_Vertex.
class TopoDSVExplorer
{
public:
TopoDSVExplorer(
const TopoDS_Vertex& theVertex,
const Standard_Boolean isSameUV,
const TopoDS_Vertex& theSameVertex)
: myVertex(theVertex),
myIsSameUV(isSameUV),
mySameVertex(theSameVertex)
{
}
const TopoDS_Vertex& Vertex() const
{
return myVertex;
}
Standard_Boolean IsSameUV() const
{
return myIsSameUV;
}
const TopoDS_Vertex& SameVertex() const
{
return mySameVertex;
}
virtual gp_Pnt Point() const
{
return BRep_Tool::Pnt(myVertex);
}
private:
void operator =(const TopoDSVExplorer& /*theOther*/)
{
}
private:
const TopoDS_Vertex& myVertex;
Standard_Boolean myIsSameUV;
const TopoDS_Vertex& mySameVertex;
};
//! Auxiliary class used to extract polygonal parameters of TopoDS_Vertex.
class PolyVExplorer : public TopoDSVExplorer
{
public:
PolyVExplorer(
const TopoDS_Vertex& theVertex,
const Standard_Boolean isSameUV,
const TopoDS_Vertex& theSameVertex,
const Standard_Integer theVertexIndex,
const TColgp_Array1OfPnt& thePolygon,
const TopLoc_Location& theLoc)
: TopoDSVExplorer(theVertex, isSameUV, theSameVertex),
myVertexIndex(theVertexIndex),
myPolygon(thePolygon),
myLoc(theLoc)
{
}
virtual gp_Pnt Point() const
{
return BRepMesh_ShapeTool::UseLocation(myPolygon(myVertexIndex), myLoc);
}
private:
void operator =(const PolyVExplorer& /*theOther*/)
{
}
private:
Standard_Integer myVertexIndex;
const TColgp_Array1OfPnt& myPolygon;
const TopLoc_Location myLoc;
};
//! Structure keeps common parameters of edge
//! used for tessellation.
struct EdgeAttributes
{
TopoDS_Vertex FirstVertex;
TopoDS_Vertex LastVertex;
Standard_Real FirstParam;
Standard_Real LastParam;
gp_Pnt2d FirstUV;
gp_Pnt2d LastUV;
Standard_Boolean IsSameUV;
Standard_Real MinDist;
N_HANDLE<TopoDSVExplorer> FirstVExtractor;
N_HANDLE<TopoDSVExplorer> LastVExtractor;
};
//! Structure keeps geometrical parameters of edge's PCurve.
//! Used for caching.
struct EdgePCurve
{
Handle(Geom2d_Curve) Curve2d;
Standard_Real FirstParam;
Standard_Real LastParam;
};
//! Fills structure of by attributes of the given edge.
//! @return TRUE on success, FALSE elsewhere.
Standard_Boolean getEdgeAttributes(
const TopoDS_Edge& theEdge,
const EdgePCurve& thePCurve,
const Standard_Real theDefEdge,
EdgeAttributes& theAttributes) const;
//! Registers end vertices of the edge in mesh data
//! structure of currently processed face.
void registerEdgeVertices(
EdgeAttributes& theAttributes,
Standard_Integer& ipf,
Standard_Integer& ivf,
Standard_Integer& isvf,
Standard_Integer& ipl,
Standard_Integer& ivl,
Standard_Integer& isvl);
//! Adds tessellated representation of the given edge to
//! mesh data structure of currently processed face.
void add(const TopoDS_Edge& theEdge,
const EdgePCurve& theCurve2D,
const Standard_Real theEdgeDeflection);
//! Updates tessellated representation of the given edge.
//! If edge already has a polygon which deflection satisfies
//! the given value, retrieves tessellation from polygon.
//! Computes tessellation using edge's geometry elsewhere.
void update(
const TopoDS_Edge& theEdge,
const Handle(Geom2d_Curve)& theCurve2D,
const Standard_Real theEdgeDeflection,
EdgeAttributes& theAttributes);
//! Adds new link to the mesh data structure.
//! Movability of the link and order of nodes depend on orientation parameter.
void addLinkToMesh(const Standard_Integer theFirstNodeId,
const Standard_Integer theLastNodeId,
const TopAbs_Orientation theOrientation);
//! Stores polygonal model of the given edge.
//! @param theEdge edge which polygonal model is stored.
//! @param thePolygon polygonal model of the edge.
//! @param theDeflection deflection with which polygonalization is performed.
//! This value is stored inside the polygon.
void storePolygon(
const TopoDS_Edge& theEdge,
Handle(Poly_PolygonOnTriangulation)& thePolygon,
const Standard_Real theDeflection);
//! Caches polygonal model of the given edge to be used in further.
//! @param theEdge edge which polygonal data is stored.
//! @param thePolygon shared polygonal data of the edge.
//! @param theDeflection deflection with which polygonalization is performed.
//! This value is stored inside the polygon.
void storePolygonSharedData(
const TopoDS_Edge& theEdge,
Handle(Poly_PolygonOnTriangulation)& thePolygon,
const Standard_Real theDeflection);
private:
Standard_Real myAngle;
Standard_Real myDeflection;
Standard_Real myDtotale;
Standard_Boolean myWithShare;
Standard_Boolean myInParallel;
BRepMeshCol::DMapOfVertexInteger myVertices;
BRepMeshCol::DMapOfShapePairOfPolygon myEdges;
BRepMeshCol::DMapOfShapePairOfPolygon myInternaledges;
Standard_Integer myNbLocat;
BRepMeshCol::DMapOfIntegerPnt myLocation3d;
Handle_BRepMesh_DataStructureOfDelaun myStructure;
BRepMeshCol::DMapOfFaceAttribute myMapattrib;
TColStd_IndexedMapOfInteger myVemap;
BRepMeshCol::DMapOfIntegerListOfXY myLocation2d;
Standard_Boolean myRelative;
Standard_Boolean myShapetrigu;
Standard_Boolean myInshape;
BRepMesh_Status myFacestate;
TopTools_DataMapOfShapeReal myMapdefle;
TopTools_ListOfShape myNottriangulated;
BRepMeshCol::Allocator myAllocator;
TopTools_MutexForShapeProvider myMutexProvider;
TopoDS_Face myFace;
Standard_Real myAngle;
Standard_Real myDeflection;
Standard_Real myDtotale;
Standard_Boolean myWithShare;
Standard_Boolean myInParallel;
BRepMeshCol::DMapOfShapePairOfPolygon myEdges;
BRepMeshCol::DMapOfFaceAttribute myAttributes;
Standard_Boolean myRelative;
Standard_Boolean myShapetrigu;
Standard_Boolean myInshape;
TopTools_DataMapOfShapeReal myMapdefle;
// Data shared for whole shape
BRepMeshCol::DMapOfVertexInteger myBoundaryVertices;
BRepMeshCol::DMapOfIntegerPnt myBoundaryPoints;
// Fast access to attributes of current face
Handle(BRepMesh_FaceAttribute) myAttribute;
Handle(BRepMesh_DataStructureOfDelaun) myStructure;
BRepMeshCol::HIMapOfInteger myVertexEdgeMap;
BRepMeshCol::HDMapOfShapePairOfPolygon myInternalEdges;
TopTools_IndexedDataMapOfShapeListOfShape mySharedFaces;
};
DEFINE_STANDARD_HANDLE(BRepMesh_FastDiscret, Standard_Transient)

2342
src/BRepMesh/BRepMesh_FastDiscretFace.cxx
View File

File diff suppressed because it is too large Load Diff

142
src/BRepMesh/BRepMesh_FastDiscretFace.hxx
View File

@ -26,6 +26,8 @@
#include <Handle_Poly_Triangulation.hxx>
#include <BRepMesh_Delaun.hxx>
#include <BRepMesh_Triangle.hxx>
#include <BRepMesh_Classifier.hxx>
#include <ElSLib.hxx>
class BRepMesh_DataStructureOfDelaun;
class BRepMesh_FaceAttribute;
@ -43,83 +45,113 @@ class BRepMesh_Vertex;
class gp_Pnt;
//! Algorithm to mesh a face with respect of the frontier
//! the deflection and by option the shared components. <br>
//! the deflection and by option the shared components.
class BRepMesh_FastDiscretFace : public Standard_Transient
{
public:
Standard_EXPORT BRepMesh_FastDiscretFace(const Standard_Real theAngle,
const Standard_Boolean theWithShare = Standard_True);
Standard_EXPORT void Add(const TopoDS_Face& theFace,
const Handle(BRepMesh_FaceAttribute)& theAttrib,
const TopTools_DataMapOfShapeReal& theMapDefle,
const TopTools_MutexForShapeProvider& theMutexProvider);
Standard_EXPORT Standard_Real Control(const Handle(BRepAdaptor_HSurface)& theCaro,
const Standard_Real theDefFace,
BRepMeshCol::ListOfVertex& theInternalV,
BRepMeshCol::ListOfInteger& theBadTriangles,
BRepMeshCol::ListOfInteger& theNulTriangles,
BRepMesh_Delaun& theTrigu,
const Standard_Boolean theIsFirst);
Standard_EXPORT void Add(const Handle(BRepMesh_FaceAttribute)& theAttribute);
//! Gives the triangle of <Index>. <br>
Standard_EXPORT const BRepMesh_Triangle& Triangle(const Standard_Integer theIndex) const;
//! Gives the edge of index <Index>. <br>
Standard_EXPORT const BRepMesh_Edge& Edge(const Standard_Integer theIndex) const;
//! Gives the vertex of <Index>. <br>
Standard_EXPORT const BRepMesh_Vertex& Vertex(const Standard_Integer theIndex) const;
//! Gives the location3d of the vertex of <Index>. <br>
Standard_EXPORT const gp_Pnt& Pnt(const Standard_Integer theIndex) const;
DEFINE_STANDARD_RTTI(BRepMesh_FastDiscretFace)
protected:
Standard_Boolean RestoreStructureFromTriangulation(const TopoDS_Edge& theEdge,
const TopoDS_Face& theFace,
const Handle(BRepAdaptor_HSurface)& theSurf,
const Handle(Poly_Triangulation)& theTrigu,
const Standard_Real theDefEdge,
const TopLoc_Location& theLoc,
const TopTools_MutexForShapeProvider& theMutexProvider);
private:
private:
void add(const TopoDS_Vertex& theVertex);
Standard_Real control(BRepMeshCol::ListOfVertex& theNewVertices,
BRepMesh_Delaun& theMeshBuilder,
const Standard_Boolean theIsFirst);
//! Registers the given nodes in mesh data structure and
//! performs refinement of existing mesh.
//! @param theVertices nodes to be inserted.
//! @param theMeshBuilder initialized tool refining mesh
//! in respect to inserting nodes.
//! @return TRUE if vertices were been inserted, FALSE elewhere.
Standard_Boolean addVerticesToMesh(
const BRepMeshCol::ListOfVertex& theVertices,
BRepMesh_Delaun& theMeshBuilder);
//! Calculates nodes lying on face's surface and inserts them to a mesh.
//! @param theNewVertices list of vertices to be extended and added to mesh.
//! @param theMeshBuilder initialized tool refining mesh
//! in respect to inserting nodes.
void insertInternalVertices(BRepMeshCol::ListOfVertex& theNewVertices,
BRepMesh_Delaun& theMeshBuilder);
//! Calculates nodes lying on spherical surface.
//! @param theNewVertices list of vertices to be extended and added to mesh.
void insertInternalVerticesSphere(BRepMeshCol::ListOfVertex& theNewVertices);
//! Calculates nodes lying on cylindrical surface.
//! @param theNewVertices list of vertices to be extended and added to mesh.
void insertInternalVerticesCylinder(BRepMeshCol::ListOfVertex& theNewVertices);
//! Calculates nodes lying on conical surface.
//! @param theNewVertices list of vertices to be extended and added to mesh.
void insertInternalVerticesCone(BRepMeshCol::ListOfVertex& theNewVertices);
//! Calculates nodes lying on toroidal surface.
//! @param theNewVertices list of vertices to be extended and added to mesh.
void insertInternalVerticesTorus(BRepMeshCol::ListOfVertex& theNewVertices);
//! Calculates nodes lying on Bezier/BSpline surface.
//! @param theNewVertices list of vertices to be extended and added to mesh.
void insertInternalVerticesBSpline(BRepMeshCol::ListOfVertex& theNewVertices);
//! Calculates nodes lying on custom-type surface.
//! @param theNewVertices list of vertices to be extended and added to mesh.
void insertInternalVerticesOther(BRepMeshCol::ListOfVertex& theNewVertices);
void Add(const TopoDS_Vertex& theVert,
const TopoDS_Face& theFace,
const Handle(BRepAdaptor_HSurface)& theSFace);
void InternalVertices(const Handle(BRepAdaptor_HSurface)& theCaro,
BRepMeshCol::ListOfVertex& theInternalV,
const Standard_Real theDefFace,
const BRepMeshCol::HClassifier& theClassifier);
void AddInShape(const TopoDS_Face& theFace,
const Standard_Real theDefFace,
const TopTools_MutexForShapeProvider& theMutexProvider);
//! Template method trying to insert new internal vertex corresponded to
//! the given 2d point. Calculates 3d position analytically using the given
//! surface.
//! @param thePnt2d 2d point to be inserted to the list.
//! @param theAnalyticSurface analytic surface to calculate 3d point.
//! @param[out] theVertices list of vertices to be updated.
template<class AnalyticSurface>
void tryToInsertAnalyticVertex(const gp_Pnt2d& thePnt2d,
const AnalyticSurface& theAnalyticSurface,
BRepMeshCol::ListOfVertex& theVertices)
{
if (!myClassifier->Perform(thePnt2d) == TopAbs_IN)
return;
gp_Pnt aPnt;
ElSLib::D0(thePnt2d.X(), thePnt2d.Y(), theAnalyticSurface, aPnt);
insertVertex(aPnt, thePnt2d.Coord(), theVertices);
}
//! Creates new vertex with the given parameters.
//! @param thePnt3d 3d point corresponded to the vertex.
//! @param theUV UV point corresponded to the vertex.
//! @param[out] theVertices list of vertices to be updated.
void insertVertex(const gp_Pnt& thePnt3d,
const gp_XY& theUV,
BRepMeshCol::ListOfVertex& theVertices);
private:
Standard_Real myAngle;
Standard_Boolean myWithShare;
BRepMeshCol::DMapOfVertexInteger myVertices;
BRepMeshCol::DMapOfShapePairOfPolygon myInternaledges;
Standard_Integer myNbLocat;
BRepMeshCol::DMapOfIntegerPnt myLocation3d;
Handle_BRepMesh_DataStructureOfDelaun myStructure;
BRepMeshCol::ListOfVertex myListver;
BRepMeshCol::IMapOfInteger myVemap;
BRepMeshCol::DMapOfIntegerListOfXY myLocation2d;
Handle_BRepMesh_FaceAttribute myAttrib;
Standard_Boolean myInternalVerticesMode;
BRepMeshCol::IMapOfReal myUParam;
BRepMeshCol::IMapOfReal myVParam;
BRepMeshCol::Allocator myAllocator;
// Fast access to attributes of current face
Handle(BRepMesh_FaceAttribute) myAttribute;
Handle(BRepMesh_DataStructureOfDelaun) myStructure;
BRepMeshCol::HIMapOfInteger myVertexEdgeMap;
BRepMeshCol::HClassifier myClassifier;
BRepMeshCol::HDMapOfIntegerPnt mySurfacePoints;
};
DEFINE_STANDARD_HANDLE (BRepMesh_FastDiscretFace, Standard_Transient)

19
src/BRepMesh/BRepMesh_IEdgeTool.cxx Normal file
View File

@ -0,0 +1,19 @@
// Created on: 2014-08-13
// Created by: Oleg AGASHIN
// Copyright (c) 2011-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <BRepMesh_IEdgeTool.hxx>
IMPLEMENT_STANDARD_HANDLE (BRepMesh_IEdgeTool, Standard_Transient)
IMPLEMENT_STANDARD_RTTIEXT(BRepMesh_IEdgeTool, Standard_Transient)

46
src/BRepMesh/BRepMesh_IEdgeTool.hxx Normal file
View File

@ -0,0 +1,46 @@
// Created on: 2014-08-13
// Created by: Oleg AGASHIN
// Copyright (c) 2011-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _BRepMesh_IEdgeTool_HeaderFile
#define _BRepMesh_IEdgeTool_HeaderFile
#include <Standard.hxx>
#include <gp_Pnt.hxx>
#include <gp_Pnt2d.hxx>
#include <Standard_Transient.hxx>
//! Interface class providing API for edge tessellation tools.
class BRepMesh_IEdgeTool : public Standard_Transient
{
public:
//! Returns number of tessellation points.
virtual Standard_Integer NbPoints() const = 0;
//! Returns parameters of solution with the given index.
//! @param theIndex index of tessellation point.
//! @param theParameter parameters on PCurve corresponded to the solution.
//! @param thePoint tessellation point.
//! @param theUV coordinates of tessellation point in parametric space of face.
virtual void Value(const Standard_Integer theIndex,
Standard_Real& theParameter,
gp_Pnt& thePoint,
gp_Pnt2d& theUV) = 0;
DEFINE_STANDARD_RTTI(BRepMesh_IEdgeTool)
};
DEFINE_STANDARD_HANDLE(BRepMesh_IEdgeTool, Standard_Transient)
#endif

171
src/BRepMesh/BRepMesh_IncrementalMesh.cxx
View File

@ -17,7 +17,7 @@
#include <BRepMesh_IncrementalMesh.hxx>
#include <Precision.hxx>
#include <Standard_Mutex.hxx>
#include <Standard_ErrorHandler.hxx>
#include <BRepMesh_FaceChecker.hxx>
#include <BRepMesh_ShapeTool.hxx>
@ -45,10 +45,11 @@
#include <TopExp_Explorer.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopTools_MutexForShapeProvider.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <TopTools_HArray1OfShape.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <GCPnts_TangentialDeflection.hxx>
@ -90,10 +91,10 @@ BRepMesh_IncrementalMesh::BRepMesh_IncrementalMesh(
: myRelative (isRelative),
myInParallel(isInParallel)
{
myDeflection = theLinDeflection;
myAngle = theAngDeflection;
myShape = theShape;
myDeflection = theLinDeflection;
myAngle = theAngDeflection;
myShape = theShape;
Perform();
}
@ -115,7 +116,6 @@ void BRepMesh_IncrementalMesh::init()
myModified = Standard_False;
myEdgeDeflection.Clear();
mySharedFaces.Clear();
myFaces.clear();
setDone();
@ -129,15 +129,16 @@ void BRepMesh_IncrementalMesh::init()
if (aBox.IsVoid())
{
// Nothing to mesh.
myMesher.Nullify();
myMesh.Nullify();
return;
}
BRepMesh_ShapeTool::BoxMaxDimension(aBox, myMaxShapeSize);
TopExp::MapShapesAndAncestors(myShape, TopAbs_EDGE, TopAbs_FACE, mySharedFaces);
myMesher = new BRepMesh_FastDiscret(myDeflection, myAngle, aBox,
myMesh = new BRepMesh_FastDiscret(myDeflection, myAngle, aBox,
Standard_True, Standard_True, myRelative, Standard_True, myInParallel);
myMesh->InitSharedFaces(myShape);
}
//=======================================================================
@ -208,7 +209,7 @@ void BRepMesh_IncrementalMesh::Perform()
{
init();
if (myMesher.IsNull())
if (myMesh.IsNull())
return;
update();
@ -240,20 +241,18 @@ void BRepMesh_IncrementalMesh::update()
#ifdef HAVE_TBB
if (myInParallel)
{
myMesher->CreateMutexesForSubShapes(myShape, TopAbs_EDGE);
tbb::parallel_for_each(myFaces.begin(), myFaces.end(), *myMesher);
myMesher->RemoveAllMutexes();
tbb::parallel_for_each(myFaces.begin(), myFaces.end(), *myMesh);
}
else
{
#endif
for (aFaceIt = myFaces.begin(); aFaceIt != myFaces.end(); aFaceIt++)
myMesher->Process(*aFaceIt);
myMesh->Process(*aFaceIt);
#ifdef HAVE_TBB
}
#endif
discretizeFreeEdges();
commit();
}
//=======================================================================
@ -361,8 +360,11 @@ void BRepMesh_IncrementalMesh::update(const TopoDS_Edge& theEdge)
if (!aTriangulation.IsNull() && !aPolygon.IsNull())
{
if (aPolygon->Deflection() < 1.1 * aEdgeDeflection)
if (aPolygon->Deflection() < 1.1 * aEdgeDeflection &&
aPolygon->HasParameters())
{
continue;
}
myModified = Standard_True;
BRepMesh_ShapeTool::NullifyEdge(theEdge, aTriangulation, aLoc);
@ -371,7 +373,8 @@ void BRepMesh_IncrementalMesh::update(const TopoDS_Edge& theEdge)
if (!myEmptyEdges.IsBound(theEdge))
myEmptyEdges.Bind(theEdge, BRepMeshCol::MapOfTriangulation());
myEmptyEdges(theEdge).Add(aTriangulation);
if (!aTriangulation.IsNull())
myEmptyEdges(theEdge).Add(aTriangulation);
}
while (!aPolygon.IsNull());
}
@ -404,7 +407,8 @@ Standard_Boolean BRepMesh_IncrementalMesh::toBeMeshed(
if (!myEmptyEdges.IsBound(aEdge))
continue;
isEdgesConsistent &= myEmptyEdges(aEdge).Contains(aTriangulation);
BRepMeshCol::MapOfTriangulation& aTriMap = myEmptyEdges(aEdge);
isEdgesConsistent &= !aTriMap.IsEmpty() && !aTriMap.Contains(aTriangulation);
}
if (isEdgesConsistent)
@ -434,24 +438,26 @@ void BRepMesh_IncrementalMesh::update(const TopoDS_Face& theFace)
return;
myModified = Standard_True;
myMesher->Add(theFace, mySharedFaces);
Standard_Integer aStatus = myMesh->Add(theFace);
BRepMesh_Status aStatus = myMesher->CurrentFaceStatus();
myStatus |= (Standard_Integer)aStatus;
myStatus |= aStatus;
if (aStatus != BRepMesh_ReMesh)
return;
BRepMeshCol::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 (mySharedFaces.FindIndex(aEdge) == 0)
if (aMapOfSharedFaces.FindIndex(aEdge) == 0)
continue;
const TopTools_ListOfShape& aSharedFaces = mySharedFaces.FindFromKey(aEdge);
const TopTools_ListOfShape& aSharedFaces = aMapOfSharedFaces.FindFromKey(aEdge);
TopTools_ListIteratorOfListOfShape aSharedFaceIt(aSharedFaces);
for (; aSharedFaceIt.More(); aSharedFaceIt.Next())
{
@ -462,12 +468,123 @@ void BRepMesh_IncrementalMesh::update(const TopoDS_Face& theFace)
aUsedFaces.Add(aFace);
toBeMeshed(aFace, Standard_False);
myMesher->Add(aFace, mySharedFaces);
myStatus |= (Standard_Integer)myMesher->CurrentFaceStatus();
myStatus |= myMesh->Add(aFace);
}
}
}
//=======================================================================
//function : commit
//purpose :
//=======================================================================
void BRepMesh_IncrementalMesh::commit()
{
std::vector<TopoDS_Face>::iterator aFaceIt(myFaces.begin());
for (; aFaceIt != myFaces.end(); aFaceIt++)
commitFace(*aFaceIt);
discretizeFreeEdges();
}
//=======================================================================
//function : commitFace
//purpose :
//=======================================================================
void BRepMesh_IncrementalMesh::commitFace(const TopoDS_Face& theFace)
{
TopoDS_Face aFace = theFace;
aFace.Orientation(TopAbs_FORWARD);
Handle(BRepMesh_FaceAttribute) aFaceAttribute;
if (!myMesh->GetFaceAttribute(aFace, aFaceAttribute))
return;
BRepMesh_ShapeTool::NullifyFace(aFace);
if (!aFaceAttribute->IsValid())
{
myStatus |= aFaceAttribute->GetStatus();
return;
}
TopLoc_Location aLoc = aFace.Location();
Handle(Poly_Triangulation) aOldTriangulation = BRep_Tool::Triangulation(aFace, aLoc);
try
{
OCC_CATCH_SIGNALS
Handle(BRepMesh_DataStructureOfDelaun)& aStructure = aFaceAttribute->ChangeStructure();
const BRepMeshCol::MapOfInteger& aTriangles = aStructure->ElementsOfDomain();
if (aTriangles.IsEmpty())
return;
BRepMeshCol::HIMapOfInteger& aVetrexEdgeMap = aFaceAttribute->ChangeVertexEdgeMap();
// Store triangles
Standard_Integer aVerticesNb = aVetrexEdgeMap->Extent();
Standard_Integer aTrianglesNb = aTriangles.Extent();
Handle(Poly_Triangulation) aNewTriangulation =
new Poly_Triangulation(aVerticesNb, aTrianglesNb, Standard_True);
Poly_Array1OfTriangle& aPolyTrianges = aNewTriangulation->ChangeTriangles();
Standard_Integer aTriangeId = 1;
BRepMeshCol::MapOfInteger::Iterator aTriIt(aTriangles);
for (; aTriIt.More(); aTriIt.Next())
{
const BRepMesh_Triangle& aCurElem = aStructure->GetElement(aTriIt.Key());
Standard_Integer aNode[3];
aStructure->ElementNodes(aCurElem, aNode);
Standard_Integer aNodeId[3];
for (Standard_Integer i = 0; i < 3; ++i)
aNodeId[i] = aVetrexEdgeMap->FindIndex(aNode[i]);
aPolyTrianges(aTriangeId++).Set(aNodeId[0], aNodeId[1], aNodeId[2]);
}
// Store mesh nodes
TColgp_Array1OfPnt& aNodes = aNewTriangulation->ChangeNodes();
TColgp_Array1OfPnt2d& aNodes2d = aNewTriangulation->ChangeUVNodes();
for (Standard_Integer i = 1; i <= aVerticesNb; ++i)
{
Standard_Integer aVertexId = aVetrexEdgeMap->FindKey(i);
const BRepMesh_Vertex& aVertex = aStructure->GetNode(aVertexId);
const gp_Pnt& aPoint = aFaceAttribute->GetPoint(aVertex);
aNodes(i) = aPoint;
aNodes2d(i) = aVertex.Coord();
}
aNewTriangulation->Deflection(aFaceAttribute->GetDefFace());
BRepMesh_ShapeTool::AddInFace(aFace, aNewTriangulation);
// Store discretization of edges
BRepMeshCol::HDMapOfShapePairOfPolygon& aInternalEdges = aFaceAttribute->ChangeInternalEdges();
BRepMeshCol::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();
BRepMesh_ShapeTool::NullifyEdge(aEdge, aOldTriangulation, aLoc);
if (aPolygon1 == aPolygon2)
BRepMesh_ShapeTool::UpdateEdge(aEdge, aPolygon1, aNewTriangulation, aLoc);
else
BRepMesh_ShapeTool::UpdateEdge(aEdge, aPolygon1, aPolygon2, aNewTriangulation, aLoc);
}
}
catch (Standard_Failure)
{
myStatus |= BRepMesh_Failure;
}
}
//=======================================================================
//function : Discret
//purpose :
@ -476,7 +593,7 @@ Standard_Integer BRepMesh_IncrementalMesh::Discret(
const TopoDS_Shape& theShape,
const Standard_Real theDeflection,
const Standard_Real theAngle,
BRepMesh_PDiscretRoot& theAlgo)
BRepMesh_DiscretRoot* &theAlgo)
{
BRepMesh_IncrementalMesh* anAlgo = new BRepMesh_IncrementalMesh();
anAlgo->SetDeflection(theDeflection);

34
src/BRepMesh/BRepMesh_IncrementalMesh.hxx
View File

@ -20,9 +20,7 @@
#include <BRepMesh_FastDiscret.hxx>
#include <TopTools_MapOfShape.hxx>
#include <TopTools_DataMapOfShapeReal.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <BRepMesh_DiscretRoot.hxx>
#include <BRepMesh_PDiscretRoot.hxx>
#include <Handle_Poly_Triangulation.hxx>
#include <BRepMesh_Collections.hxx>
@ -116,7 +114,7 @@ public: //! \name plugin API
Standard_EXPORT static Standard_Integer Discret(const TopoDS_Shape& theShape,
const Standard_Real theLinDeflection,
const Standard_Real theAngDeflection,
BRepMesh_PDiscretRoot& theAlgo);
BRepMesh_DiscretRoot* &theAlgo);
//! Returns multi-threading usage flag set by default in
//! Discret() static method (thus applied only to Mesh Factories).
@ -126,6 +124,11 @@ public: //! \name plugin API
//! Discret() static method (thus applied only to Mesh Factories).
Standard_EXPORT static void SetParallelDefault(const Standard_Boolean isInParallel);
//! Returns mesh tool storing mesh data.
inline const Handle(BRepMesh_FastDiscret)& Mesh() const
{
return myMesh;
}
DEFINE_STANDARD_RTTI(BRepMesh_IncrementalMesh)
@ -183,18 +186,23 @@ private:
Standard_Boolean toBeMeshed(const TopoDS_Face& theFace,
const Standard_Boolean isWithCheck);
//! Stores mesh to the shape.
void commit();
//! Stores mesh to the face.
void commitFace(const TopoDS_Face& theFace);
protected:
Standard_Boolean myRelative;
Standard_Boolean myInParallel;
BRepMeshCol::DMapOfEdgeListOfTriangulation myEmptyEdges;
Handle(BRepMesh_FastDiscret) myMesher;
Standard_Boolean myModified;
TopTools_DataMapOfShapeReal myEdgeDeflection;
TopTools_IndexedDataMapOfShapeListOfShape mySharedFaces;
Standard_Real myMaxShapeSize;
Standard_Integer myStatus;
std::vector<TopoDS_Face> myFaces;
Standard_Boolean myRelative;
Standard_Boolean myInParallel;
BRepMeshCol::DMapOfEdgeListOfTriangulation myEmptyEdges;
Handle(BRepMesh_FastDiscret) myMesh;
Standard_Boolean myModified;
TopTools_DataMapOfShapeReal myEdgeDeflection;
Standard_Real myMaxShapeSize;
Standard_Integer myStatus;
std::vector<TopoDS_Face> myFaces;
};
DEFINE_STANDARD_HANDLE(BRepMesh_IncrementalMesh,BRepMesh_DiscretRoot)

10
src/BRepMesh/BRepMesh_PluginMacro.hxx
View File

@ -21,13 +21,13 @@ extern "C" { \
Standard_EXPORT Standard_Integer DISCRETALGO(const TopoDS_Shape& , \
const Standard_Real, \
const Standard_Real, \
BRepMesh_PDiscretRoot& ); \
BRepMesh_DiscretRoot* &); \
} \
\
Standard_Integer DISCRETALGO(const TopoDS_Shape& theShape, \
const Standard_Real theLinDeflection, \
const Standard_Real theAngDeflection, \
BRepMesh_PDiscretRoot& theAlgo) \
Standard_Integer DISCRETALGO(const TopoDS_Shape& theShape, \
const Standard_Real theLinDeflection, \
const Standard_Real theAngDeflection, \
BRepMesh_DiscretRoot* &theAlgo) \
{ \
return name::Discret(theShape, theLinDeflection, \
theAngDeflection, theAlgo); \

106
src/BRepMesh/BRepMesh_ShapeTool.cxx
View File

@ -24,6 +24,8 @@
#include <TColgp_Array1OfPnt.hxx>
#include <Poly_Triangulation.hxx>
#include <BRep_Builder.hxx>
#include <TopExp.hxx>
#include <BRepAdaptor_Curve.hxx>
namespace {
//! Auxilary struct to take a tolerance of edge.
@ -108,7 +110,7 @@ Standard_Real BRepMesh_ShapeTool::RelativeEdgeDeflection(
return aDefEdge;
Bnd_Box aBox;
BRepBndLib::Add(theEdge, aBox);
BRepBndLib::Add(theEdge, aBox, Standard_False);
BoxMaxDimension(aBox, aDefEdge);
// Adjust resulting value in relation to the total size
@ -126,25 +128,25 @@ Standard_Real BRepMesh_ShapeTool::RelativeEdgeDeflection(
//purpose :
//=======================================================================
gp_XY BRepMesh_ShapeTool::FindUV(
const Standard_Integer theIndexOfPnt3d,
const gp_Pnt2d& thePnt2d,
const TopoDS_Vertex& theVertex,
const Standard_Real theMinDistance,
const Handle(BRepMesh_FaceAttribute)& theFaceAttribute,
const Handle(BRepAdaptor_HSurface)& theSurface,
BRepMeshCol::DMapOfIntegerListOfXY& theLocation2dMap)
const Standard_Integer theIndexOfPnt3d,
const gp_Pnt2d& thePnt2d,
const TopoDS_Vertex& theVertex,
const Standard_Real theMinDistance,
const Handle(BRepMesh_FaceAttribute)& theFaceAttribute)
{
const gp_XY& aPnt2d = thePnt2d.Coord();
if (!theLocation2dMap.IsBound(theIndexOfPnt3d))
BRepMeshCol::DMapOfIntegerListOfXY& aLocation2D =
theFaceAttribute->ChangeLocation2D();
if (!aLocation2D.IsBound(theIndexOfPnt3d))
{
BRepMeshCol::ListOfXY aPoints2d;
aPoints2d.Append(aPnt2d);
theLocation2dMap.Bind(theIndexOfPnt3d, aPoints2d);
aLocation2D.Bind(theIndexOfPnt3d, aPoints2d);
return aPnt2d;
}
BRepMeshCol::ListOfXY& aPoints2d =
theLocation2dMap.ChangeFind(theIndexOfPnt3d);
BRepMeshCol::ListOfXY& aPoints2d = aLocation2D.ChangeFind(theIndexOfPnt3d);
// Find the most closest 2d point to the given one.
gp_XY aUV;
@ -166,23 +168,15 @@ gp_XY BRepMesh_ShapeTool::FindUV(
Min(2. * BRep_Tool::Tolerance(theVertex), theMinDistance);
// Get face limits
Standard_Real aDiffU, aDiffV;
if (theFaceAttribute.IsNull())
{
aDiffU = theSurface->LastUParameter() - theSurface->FirstUParameter();
aDiffV = theSurface->LastVParameter() - theSurface->FirstVParameter();
}
else
{
aDiffU = theFaceAttribute->GetUMax() - theFaceAttribute->GetUMin();
aDiffV = theFaceAttribute->GetVMax() - theFaceAttribute->GetVMin();
}
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 gp_Pnt aPnt1 = theSurface->Value( aUV.X(), aUV.Y());
const gp_Pnt aPnt2 = theSurface->Value(aPnt2d.X(), aPnt2d.Y());
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.
@ -272,3 +266,65 @@ void BRepMesh_ShapeTool::UpdateEdge(
aBuilder.UpdateEdge(theEdge, thePolygon1, thePolygon2,
theTriangulation, theLocation);
}
//=======================================================================
//function : UseLocation
//purpose :
//=======================================================================
gp_Pnt BRepMesh_ShapeTool::UseLocation(const gp_Pnt& thePnt,
const TopLoc_Location& theLoc)
{
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);
longueur += P1.Distance(P2);
if (longueur > tolV2)
break;
P1 = P2;
}
if (longueur < tolV2)
return Standard_True;
return Standard_False;
}

80
src/BRepMesh/BRepMesh_ShapeTool.hxx
View File

@ -43,18 +43,18 @@ public:
//! Gets the maximum dimension of the given bounding box.
//! If the given bounding box is void leaves the resulting value unchanged.
//! \param theBox bounding box to be processed.
//! \param theMaxDimension maximum dimension of the given box.
//! @param theBox bounding box to be processed.
//! @param theMaxDimension maximum dimension of the given box.
Standard_EXPORT static void BoxMaxDimension(const Bnd_Box& theBox,
Standard_Real& theMaxDimension);
//! Returns relative deflection for edge with respect to shape size.
//! \param theEdge edge for which relative deflection should be computed.
//! \param theDeflection absolute deflection.
//! \param theMaxShapeSize maximum size of a shape.
//! \param theAdjustmentCoefficient coefficient of adjustment between maximum
//! @param theEdge edge for which relative deflection should be computed.
//! @param theDeflection absolute deflection.
//! @param theMaxShapeSize maximum size of a shape.
//! @param theAdjustmentCoefficient coefficient of adjustment between maximum
//! size of shape and calculated relative deflection.
//! \return relative deflection for the edge.
//! @return relative deflection for the edge.
Standard_EXPORT static Standard_Real RelativeEdgeDeflection(
const TopoDS_Edge& theEdge,
const Standard_Real theDeflection,
@ -63,24 +63,21 @@ public:
//! Checks 2d representations of 3d point with the
//! given index for equality to avoid duplications.
//! \param theIndexOfPnt3d index of 3d point with which 2d
//! @param theIndexOfPnt3d index of 3d point with which 2d
//! representation should be associated.
//! \param thePnt2d 2d representation of the point with the
//! @param thePnt2d 2d representation of the point with the
//! given index.
//! \param theVertex vertex corresponded to 3d point with the
//! @param theVertex vertex corresponded to 3d point with the
//! given index. Used to extract vertex tolerance in 3d space.
//! \param theMinDistance minimum distance between vertices
//! @param theMinDistance minimum distance between vertices
//! regarding which they could be treated as distinct ones.
//! This value is defined by mesher using parameters given by
//! user in connection with shape metrics.
//! \param theFaceAttribute attributes contining data calculated
//! @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 theSurface surface within which parametric space
//! the 2d point is defined. Supposed to be used in case if face
//! attributes are not defined by the moment of method invocation.
//! \param theLocation2dMap map of 2d representations of 3d points.
//! \return given 2d point in case if 3d poind does not alredy have
//! @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(
@ -88,35 +85,33 @@ public:
const gp_Pnt2d& thePnt2d,
const TopoDS_Vertex& theVertex,
const Standard_Real theMinDistance,
const Handle(BRepMesh_FaceAttribute)& theFaceAttribute,
const Handle(BRepAdaptor_HSurface)& theSurface,
BRepMeshCol::DMapOfIntegerListOfXY& theLocation2dMap);
const Handle(BRepMesh_FaceAttribute)& theFaceAttribute);
//! Stores the given triangulation into the given face.
//! \param theFace face to be updated by triangulation.
//! \param theTriangulation triangulation to be stored into the face.
//! @param theFace face to be updated by triangulation.
//! @param theTriangulation triangulation to be stored into the face.
Standard_EXPORT static void AddInFace(
const TopoDS_Face& theFace,
Handle(Poly_Triangulation)& theTriangulation);
//! 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);
//! Nullifies polygon on triangulation stored in the edge.
//! \param theEdge edge to be updated by null polygon.
//! \param theTriangulation triangulation the given edge is associated to.
//! \param theLocation face location.
//! @param theEdge edge to be updated by null polygon.
//! @param theTriangulation triangulation the given edge is associated to.
//! @param theLocation face location.
Standard_EXPORT static void NullifyEdge(
const TopoDS_Edge& theEdge,
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.
//! \param theTriangulation triangulation the given edge is associated to.
//! \param theLocation face location.
//! @param theEdge edge to be updated.
//! @param thePolygon tessellated representation of the edge to be stored.
//! @param theTriangulation triangulation the given edge is associated to.
//! @param theLocation face location.
Standard_EXPORT static void UpdateEdge(
const TopoDS_Edge& theEdge,
const Handle(Poly_PolygonOnTriangulation)& thePolygon,
@ -124,19 +119,34 @@ public:
const TopLoc_Location& theLocation);
//! Updates the given seam edge by the given tessellated representations.
//! \param theEdge edge to be updated.
//! \param thePolygon1 tessellated representation corresponding to
//! @param theEdge edge to be updated.
//! @param thePolygon1 tessellated representation corresponding to
//! forward direction of the seam edge.
//! \param thePolygon2 tessellated representation corresponding to
//! @param thePolygon2 tessellated representation corresponding to
//! reversed direction of the seam edge.
//! \param theTriangulation triangulation the given edge is associated to.
//! \param theLocation face location.
//! @param theTriangulation triangulation the given edge is associated to.
//! @param theLocation face location.
Standard_EXPORT static void UpdateEdge(
const TopoDS_Edge& theEdge,
const Handle(Poly_PolygonOnTriangulation)& thePolygon1,
const Handle(Poly_PolygonOnTriangulation)& thePolygon2,
const Handle(Poly_Triangulation)& theTriangulation,
const TopLoc_Location& theLocation);
//! Applies location to the given point and return result.
//! @param thePnt point to be transformed.
//! @param theLoc location to be applied.
Standard_EXPORT static gp_Pnt UseLocation(const gp_Pnt& thePnt,
const TopLoc_Location& theLoc);
//! Checks is the given edge degenerated.
//! Checks geometrical parameters in case if IsDegenerated flag is not set.
//! @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_Face& theFace);
};
#endif

4
src/BRepMesh/BRepMesh_Vertex.hxx
View File

@ -110,8 +110,8 @@ public:
//! \return TRUE if equal, FALSE if not.
Standard_EXPORT Standard_Boolean IsEqual(const BRepMesh_Vertex& theOther) const
{
if (myMovability != BRepMesh_Deleted ||
theOther.myMovability != BRepMesh_Deleted)
if (myMovability == BRepMesh_Deleted ||
theOther.myMovability == BRepMesh_Deleted)
{
return Standard_False;
}

24
src/BRepMesh/BRepMesh_WireChecker.cxx
View File

@ -22,7 +22,7 @@
#include <BRepTools_WireExplorer.hxx>
#include <TopAbs_Orientation.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Iterator.hxx>
#include <TopExp_Explorer.hxx>
#include <Poly_PolygonOnTriangulation.hxx>
#include <BRepMesh_PairOfPolygon.hxx>
#include <TColStd_SequenceOfInteger.hxx>
@ -129,8 +129,8 @@ Standard_Integer BRepMesh_WireChecker::BndBox2dTreeSelector::IndicesNb() const
BRepMesh_WireChecker::BRepMesh_WireChecker(
const TopoDS_Face& theFace,
const Standard_Real theTolUV,
const BRepMeshCol::DMapOfShapePairOfPolygon& theEdges,
const TColStd_IndexedMapOfInteger& theVertexMap,
const BRepMeshCol::HDMapOfShapePairOfPolygon& theEdges,
const BRepMeshCol::HIMapOfInteger& theVertexMap,
const Handle(BRepMesh_DataStructureOfDelaun)& theStructure,
const Standard_Real theUmin,
const Standard_Real theUmax,
@ -151,18 +151,16 @@ BRepMesh_WireChecker::BRepMesh_WireChecker(
TopoDS_Face aFace = theFace;
aFace.Orientation(TopAbs_FORWARD);
TopoDS_Iterator aFaceExplorer(aFace);
TopExp_Explorer aFaceExplorer(aFace, TopAbs_WIRE);
for (; aFaceExplorer.More(); aFaceExplorer.Next())
{
const TopoDS_Shape& aWire = aFaceExplorer.Value();
if (aWire.ShapeType() != TopAbs_WIRE)
continue;
const TopoDS_Wire& aWire = TopoDS::Wire(aFaceExplorer.Current());
myWiresEdges.push_back(ListOfEdges());
ListOfEdges& aEdges = myWiresEdges.back();
// Start traversing the wires
BRepTools_WireExplorer aWireExplorer(TopoDS::Wire(aWire), aFace);
BRepTools_WireExplorer aWireExplorer(aWire, aFace);
for (; aWireExplorer.More(); aWireExplorer.Next())
{
const TopoDS_Edge& aEdge = aWireExplorer.Current();
@ -264,13 +262,13 @@ Standard_Boolean BRepMesh_WireChecker::collectDiscretizedWires(
{
const TopoDS_Edge& aEdge = aEdgeIt.Value();
TopAbs_Orientation aOrient = aEdge.Orientation();
if (!myEdges.IsBound(aEdge))
if (!myEdges->IsBound(aEdge))
continue;
// Retrieve polygon
// Define the direction for adding points to aSeqPnt2d
Standard_Integer aStartId, aEndId, aIncrement;
const BRepMesh_PairOfPolygon& aPair = myEdges.Find(aEdge);
const BRepMesh_PairOfPolygon& aPair = myEdges->Find(aEdge);
Handle(Poly_PolygonOnTriangulation) aNOD;
if (aOrient == TopAbs_FORWARD)
{
@ -288,8 +286,8 @@ Standard_Boolean BRepMesh_WireChecker::collectDiscretizedWires(
}
const TColStd_Array1OfInteger& aIndices = aNOD->Nodes();
const Standard_Integer aFirstVertexId = myVertexMap.FindKey(aIndices(aStartId));
const Standard_Integer aLastVertexId = myVertexMap.FindKey(aIndices(aEndId) );
const Standard_Integer aFirstVertexId = myVertexMap->FindKey(aIndices(aStartId));
const Standard_Integer aLastVertexId = myVertexMap->FindKey(aIndices(aEndId) );
if (aFirstVertexId == aLastVertexId && (aEndId - aStartId) == aIncrement)
{
@ -320,7 +318,7 @@ Standard_Boolean BRepMesh_WireChecker::collectDiscretizedWires(
{
Standard_Integer aIndex = ((i == aStartId) ?
aFirstVertexId :
myVertexMap.FindKey(aIndices(i)));
myVertexMap->FindKey(aIndices(i)));
aSeqPnt2d.Append(gp_Pnt2d(myStructure->GetNode(aIndex).Coord()));
}

8
src/BRepMesh/BRepMesh_WireChecker.hxx
View File

@ -87,8 +87,8 @@ public:
Standard_EXPORT BRepMesh_WireChecker(
const TopoDS_Face& theFace,
const Standard_Real theTolUV,
const BRepMeshCol::DMapOfShapePairOfPolygon& theEdges,
const TColStd_IndexedMapOfInteger& theVertexMap,
const BRepMeshCol::HDMapOfShapePairOfPolygon& theEdges,
const BRepMeshCol::HIMapOfInteger& theVertexMap,
const Handle(BRepMesh_DataStructureOfDelaun)& theStructure,
const Standard_Real theUmin,
const Standard_Real theUmax,
@ -129,8 +129,8 @@ private:
private:
const Standard_Real myTolUV;
const BRepMeshCol::DMapOfShapePairOfPolygon& myEdges;
const TColStd_IndexedMapOfInteger& myVertexMap;
const BRepMeshCol::HDMapOfShapePairOfPolygon& myEdges;
const BRepMeshCol::HIMapOfInteger& myVertexMap;
const Handle(BRepMesh_DataStructureOfDelaun)& myStructure;
const Standard_Real myUmin;
const Standard_Real myUmax;

8
src/BRepMesh/FILES
View File

@ -36,6 +36,14 @@ BRepMesh_EdgeChecker.hxx
BRepMesh_FaceChecker.hxx
BRepMesh_SelectorOfDataStructureOfDelaun.hxx
BRepMesh_SelectorOfDataStructureOfDelaun.cxx
BRepMesh_EdgeParameterProvider.hxx
BRepMesh_EdgeParameterProvider.cxx
BRepMesh_IEdgeTool.hxx
BRepMesh_IEdgeTool.cxx
BRepMesh_EdgeTessellationExtractor.hxx
BRepMesh_EdgeTessellationExtractor.cxx
BRepMesh_EdgeTessellator.hxx
BRepMesh_EdgeTessellator.cxx
BRepMesh_FastDiscretFace.hxx
BRepMesh_FastDiscretFace.cxx
BRepMesh_FastDiscret.hxx

1
src/IVtkOCC/IVtkOCC_ShapeMesher.cxx
View File

@ -21,7 +21,6 @@
#include <BRepBndLib.hxx>
#include <BRepMesh_DiscretFactory.hxx>
#include <BRepMesh_DiscretRoot.hxx>
#include <BRepMesh_PDiscretRoot.hxx>
#include <BRepTools.hxx>
#include <Hatch_Hatcher.hxx>
#include <GCPnts_QuasiUniformDeflection.hxx>

142
src/MeshTest/MeshTest.cxx
View File

@ -394,36 +394,30 @@ static void MeshStats(const TopoDS_Shape& theSape,
static Standard_Integer triangule(Draw_Interpretor& di, Standard_Integer nbarg, const char** argv)
{
if (nbarg < 4) return 1;
Standard_Boolean save = Standard_False;
if (nbarg < 4)
return 1;
const char *id1 = argv[2];
TopoDS_Shape S = DBRep::Get(id1);
if (S.IsNull()) return 1;
TopoDS_Shape aShape = DBRep::Get(id1);
if (aShape.IsNull())
return 1;
di << argv[1] << " ";
Standard_Real Deflect=Draw::Atof(argv[3]);
if (Deflect<=0.) {
di << " Donner la fleche !" << "\n";
Standard_Real aDeflection = Draw::Atof(argv[3]);
if (aDeflection <= 0.)
{
di << " Incorrect value of deflection!" << "\n";
return 1;
}
if (nbarg >4) {
save = (Draw::Atoi(argv[4])==1);
}
Handle(MeshTest_DrawableMesh) aDMesh =
new MeshTest_DrawableMesh(aShape, aDeflection);
Standard_Boolean partage=Standard_True;
if (nbarg>5) {
partage=Draw::Atoi(argv[5])==1;
}
Handle(MeshTest_DrawableMesh) DM =
new MeshTest_DrawableMesh(S,Deflect,partage, save);
Draw::Set(argv[1],DM);
Draw::Set(argv[1], aDMesh);
Standard_Integer nbn, nbl, nbe;
MeshStats(S, nbe, nbl, nbn);
MeshStats(aShape, nbe, nbl, nbn);
di<<"(Resultat ("<<nbe<<" mailles) ("<<nbl<<" aretes) ("<<nbn<<" sommets))"<<"\n";
@ -437,16 +431,36 @@ static Standard_Integer triangule(Draw_Interpretor& di, Standard_Integer nbarg,
}
}*/
Bnd_Box bobo;
for (Standard_Integer lepnt=1; lepnt<DM->Mesh()->NbPoint3d(); lepnt++) {
bobo.Add(DM->Mesh()->Point3d(lepnt));
Bnd_Box aBox;
const Handle(BRepMesh_FastDiscret)& aFastDiscret = aDMesh->Mesher()->Mesh();
TopExp_Explorer aFaceIt(aShape, TopAbs_FACE);
for (; aFaceIt.More(); aFaceIt.Next())
{
const TopoDS_Face& aFace = TopoDS::Face(aFaceIt.Current());
Handle(BRepMesh_FaceAttribute) anAttribute;
if (aFastDiscret->GetFaceAttribute(aFace, anAttribute) && anAttribute->IsValid())
{
const Standard_Integer aNbPnts = anAttribute->LastPointId();
for (Standard_Integer i = 1; i < aNbPnts; ++i)
aBox.Add(anAttribute->GetPoint(i));
}
}
Standard_Real x,y,z,X,Y,Z;
bobo.Get(x,y,z,X,Y,Z);
Standard_Real delta=Max(X-x,Max(Y-y,Z-z));
if (delta>0) delta=Deflect/delta;
di << " Fleche de " << delta << " fois la taille de l''objet." << "\n";
Standard_Real aDelta = 0.;
if (!aBox.IsVoid())
{
Standard_Real x, y, z, X, Y, Z;
aBox.Get(x, y, z, X, Y, Z);
aDelta = Max(X - x, Max(Y - y, Z - z));
if (aDelta > 0.0)
aDelta = aDeflection / aDelta;
}
di << " Ratio between deflection and total shape size is " << aDelta << "\n";
return 0;
}
@ -546,36 +560,60 @@ return 0;
//function : vertices
//purpose :
//=======================================================================
static Standard_Integer vertices (Draw_Interpretor&, Standard_Integer n, const char** a)
static Standard_Integer vertices(
Draw_Interpretor& /*di*/,
Standard_Integer /*argc*/,
const char** /*argv*/)
{
if (n < 3) return 1;
return 0;
Handle(MeshTest_DrawableMesh) D =
Handle(MeshTest_DrawableMesh)::DownCast(Draw::Get(a[1]));
if (D.IsNull()) return 1;
TopoDS_Shape S = DBRep::Get(a[2]);
if (S.IsNull()) return 1;
// TODO: OAN re-implement this command according changes in BRepMesh
//if (argc < 3)
// return 1;
TopExp_Explorer ex;
TColStd_SequenceOfInteger& vseq = D->Vertices();
Handle(BRepMesh_FastDiscret) M = D->Mesh();
//Handle(MeshTest_DrawableMesh) aDrawableMesh =
// Handle(MeshTest_DrawableMesh)::DownCast(Draw::Get(argv[1]));
//if (aDrawableMesh.IsNull())
// return 1;
// the faces
for (ex.Init(S,TopAbs_FACE);ex.More();ex.Next()) {
BRepMeshCol::MapOfInteger vtx;
M->VerticesOfDomain(vtx);
for (BRepMeshCol::MapOfInteger::Iterator it(vtx); it.More(); it.Next())
vseq.Append(it.Key());
}
//TopoDS_Shape aShape = DBRep::Get(argv[2]);
//if (aShape.IsNull())
// return 1;
//TColStd_SequenceOfInteger& aVertexSeq = aDrawableMesh->Vertices();
//Handle(BRepMesh_FastDiscret) aMesh = aDrawableMesh->Mesh();
// the edges
//for (ex.Init(S,TopAbs_EDGE,TopAbs_FACE);ex.More();ex.Next()) {
//TopExp_Explorer aFaceIt(aShape, TopAbs_FACE);
//for (; aFaceIt.More(); aFaceIt.Next())
//{
// const TopoDS_Face& aFace = TopoDS::Face(aFaceIt.Current());
// Handle(BRepMesh_FaceAttribute) aAttribute;
// if (aMesh->GetFaceAttribute(aFace, aAttribute))
// {
// Handle(BRepMesh_DataStructureOfDelaun) aStructure = aAttribute->EditStructure();
// // Recuperate from the map of edges.
// const BRepMeshCol::MapOfInteger& aEdgeMap = aStructure->LinksOfDomain();
// // Iterator on edges.
// BRepMeshCol::MapOfInteger aVertices;
// BRepMeshCol::MapOfInteger::Iterator aEdgeIt(aEdgeMap);
// for (; aEdgeIt.More(); aEdgeIt.Next())
// {
// const BRepMesh_Edge& aEdge = aStructure->GetLink(aEdgeIt.Key());
// aVertices.Add(aEdge.FirstNode());
// aVertices.Add(aEdge.LastNode());
// }
// BRepMeshCol::MapOfInteger::Iterator anIt(vtx);
// for ( ; anIt.More(); anIt.Next() )
// aVertexSeq.Append(anIt.Key());
// }
//}
Draw::Repaint();
return 0;
//Draw::Repaint();
//return 0;
}
//=======================================================================
@ -1504,7 +1542,7 @@ void MeshTest::Commands(Draw_Interpretor& theCommands)
theCommands.Add("incmesh","incmesh shape deflection [inParallel (0/1) : 0 by default]",__FILE__, incrementalmesh, g);
theCommands.Add("MemLeakTest","MemLeakTest",__FILE__, MemLeakTest, g);
theCommands.Add("fastdiscret","fastdiscret shape deflection [shared [nbiter]]",__FILE__, fastdiscret, g);
theCommands.Add("mesh","mesh result Shape deflection [save partage]",__FILE__, triangule, g);
theCommands.Add("mesh","mesh result Shape deflection",__FILE__, triangule, g);
theCommands.Add("addshape","addshape meshname Shape [deflection]",__FILE__, addshape, g);
//theCommands.Add("smooth","smooth meshname",__FILE__, smooth, g);
//theCommands.Add("edges","edges mesh shape, highlight the edges",__FILE__,edges, g);

114
src/MeshTest/MeshTest_DrawableMesh.cxx
View File

@ -26,8 +26,7 @@
#include <BRepMesh_Vertex.hxx>
#include <BRepMesh_Triangle.hxx>
#include <BRepMesh_DataStructureOfDelaun.hxx>
#include <Bnd_Box.hxx>
#include <BRepBndLib.hxx>
#include <TopExp_Explorer.hxx>
IMPLEMENT_STANDARD_HANDLE (MeshTest_DrawableMesh, Draw_Drawable3D)
IMPLEMENT_STANDARD_RTTIEXT(MeshTest_DrawableMesh, Draw_Drawable3D)
@ -36,9 +35,8 @@ IMPLEMENT_STANDARD_RTTIEXT(MeshTest_DrawableMesh, Draw_Drawable3D)
//function : MeshTest_DrawableMesh
//purpose :
//=======================================================================
MeshTest_DrawableMesh::MeshTest_DrawableMesh() :
myDeflection(1.), myinshape(Standard_False)
MeshTest_DrawableMesh::MeshTest_DrawableMesh()
: myDeflection(1.)
{
}
@ -46,56 +44,41 @@ myDeflection(1.), myinshape(Standard_False)
//function : MeshTest_DrawableMesh
//purpose :
//=======================================================================
MeshTest_DrawableMesh::MeshTest_DrawableMesh(const TopoDS_Shape& S,
const Standard_Real Deflect,
const Standard_Boolean Partage,
const Standard_Boolean inshape) :
myDeflection(Deflect), myinshape(inshape)
MeshTest_DrawableMesh::MeshTest_DrawableMesh(const TopoDS_Shape& theShape,
const Standard_Real theDeflection)
: myDeflection(theDeflection)
{
Bnd_Box B;
BRepBndLib::Add(S, B);
myMesh = new BRepMesh_FastDiscret(S, Deflect, 0.5, B, Partage, inshape);
Add(theShape);
}
//=======================================================================
//function : MeshTest_DrawableMesh
//purpose :
//=======================================================================
MeshTest_DrawableMesh::MeshTest_DrawableMesh(const Handle(BRepMesh_FastDiscret)& Tr):
myDeflection(1.0)
MeshTest_DrawableMesh::MeshTest_DrawableMesh(
const Handle(BRepMesh_IncrementalMesh)& theMesher)
: myDeflection(1.)
{
myMesh = Tr;
myMesher = theMesher;
if (!myMesher.IsNull())
myDeflection = myMesher->Deflection();
}
//=======================================================================
//function : MeshTest_DrawableMesh
//purpose :
//=======================================================================
void MeshTest_DrawableMesh::Add(const TopoDS_Shape& S)
void MeshTest_DrawableMesh::Add(const TopoDS_Shape& theShape)
{
Bnd_Box B;
BRepBndLib::Add(S, B);
if (myMesh.IsNull())
myMesh=new BRepMesh_FastDiscret(S, myDeflection, 0.5, B, myinshape);
else
myMesh->Perform(S);
}
//=======================================================================
//function : AddInShape
//purpose :
//=======================================================================
void MeshTest_DrawableMesh::AddInShape(const Standard_Boolean inshape)
{
myinshape = inshape;
if (myMesher.IsNull())
{
myMesher = new BRepMesh_IncrementalMesh;
myMesher->SetDeflection(myDeflection);
myMesher->SetAngle(0.5);
}
myMesher->SetShape(theShape);
myMesher->Perform();
}
//=======================================================================
@ -172,18 +155,15 @@ void MeshTest_DrawableMesh::DrawOn(Draw_Display& /*D*/) const
//function : Copy
//purpose :
//=======================================================================
Handle(Draw_Drawable3D) MeshTest_DrawableMesh::Copy() const
{
Handle(MeshTest_DrawableMesh) D = new MeshTest_DrawableMesh();
return D;
return new MeshTest_DrawableMesh(myMesher);
}
//=======================================================================
//function : Dump
//purpose :
//=======================================================================
void MeshTest_DrawableMesh::Dump(Standard_OStream&) const
{
// Should be reimplemented
@ -239,24 +219,45 @@ void MeshTest_DrawableMesh::Dump(Standard_OStream&) const
//function : Whatis
//purpose :
//=======================================================================
void MeshTest_DrawableMesh::Whatis(Draw_Interpretor& S) const
void MeshTest_DrawableMesh::Whatis(Draw_Interpretor& theStream) const
{
S << " 3d mesh\n";
S << " - Triangles : " << myMesh->NbTriangles() << "\n";
S << " - Edges : " << myMesh->NbEdges() << "\n";
S << " - Vertices : " << myMesh->NbVertices() << "\n";
S << " - Point3d : " << myMesh->NbPoint3d() << "\n";
const Handle(BRepMesh_FastDiscret)& aMesh = myMesher->Mesh();
Standard_Integer aPointsNb = aMesh->NbBoundaryPoints();
Standard_Integer aTrianglesNb = 0;
Standard_Integer aEdgesNb = 0;
const TopoDS_Shape& aShape = myMesher->Shape();
TopExp_Explorer aFaceIt(aShape, TopAbs_FACE);
for (; aFaceIt.More(); aFaceIt.Next())
{
const TopoDS_Face& aFace = TopoDS::Face(aFaceIt.Current());
Handle(BRepMesh_FaceAttribute) aAtrribure;
if (!aMesh->GetFaceAttribute(aFace, aAtrribure) || !aAtrribure->IsValid())
continue;
aPointsNb += aAtrribure->ChangeSurfacePoints()->Extent();
Handle(BRepMesh_DataStructureOfDelaun)& aStructure =
aAtrribure->ChangeStructure();
aTrianglesNb += aStructure->ElementsOfDomain().Extent();
aEdgesNb += aStructure->LinksOfDomain().Extent();
}
theStream << " 3d mesh\n";
theStream << " - Triangles : " << aTrianglesNb << "\n";
theStream << " - Edges : " << aEdgesNb << "\n";
theStream << " - Point3d : " << aPointsNb << "\n";
}
//=======================================================================
//function : Mesh
//function : Mesher
//purpose :
//=======================================================================
Handle(BRepMesh_FastDiscret) MeshTest_DrawableMesh::Mesh() const
const Handle(BRepMesh_IncrementalMesh)& MeshTest_DrawableMesh::Mesher() const
{
return myMesh;
return myMesher;
}
@ -264,7 +265,6 @@ Handle(BRepMesh_FastDiscret) MeshTest_DrawableMesh::Mesh() const
//function : Edges
//purpose :
//=======================================================================
TColStd_SequenceOfInteger& MeshTest_DrawableMesh::Edges()
{
return myEdges;
@ -275,7 +275,6 @@ TColStd_SequenceOfInteger& MeshTest_DrawableMesh::Edges()
//function : Vertices
//purpose :
//=======================================================================
TColStd_SequenceOfInteger& MeshTest_DrawableMesh::Vertices()
{
return myVertices;
@ -285,7 +284,6 @@ TColStd_SequenceOfInteger& MeshTest_DrawableMesh::Vertices()
//function : Triangles
//purpose :
//=======================================================================
TColStd_SequenceOfInteger& MeshTest_DrawableMesh::Triangles()
{
return myTriangles;

38
src/MeshTest/MeshTest_DrawableMesh.hxx
View File

@ -16,7 +16,7 @@
#include <Standard.hxx>
#include <Standard_DefineHandle.hxx>
#include <BRepMesh_FastDiscret.hxx>
#include <BRepMesh_IncrementalMesh.hxx>
#include <TColStd_SequenceOfInteger.hxx>
#include <Draw_Drawable3D.hxx>
#include <Handle_Draw_Drawable3D.hxx>
@ -37,40 +37,38 @@ public:
Standard_EXPORT MeshTest_DrawableMesh();
Standard_EXPORT MeshTest_DrawableMesh(const TopoDS_Shape& S,const Standard_Real Deflect,const Standard_Boolean Partage,const Standard_Boolean InShape = Standard_False);
Standard_EXPORT MeshTest_DrawableMesh(const TopoDS_Shape& theShape,
const Standard_Real theDeflection);
Standard_EXPORT MeshTest_DrawableMesh(const Handle(BRepMesh_FastDiscret)& Tr);
Standard_EXPORT MeshTest_DrawableMesh(const Handle(BRepMesh_IncrementalMesh)& theMesher);
Standard_EXPORT void AddInShape(const Standard_Boolean inshape) ;
Standard_EXPORT void Add(const TopoDS_Shape& theShape);
Standard_EXPORT void Add(const TopoDS_Shape& S) ;
Standard_EXPORT TColStd_SequenceOfInteger& Edges();
Standard_EXPORT TColStd_SequenceOfInteger& Edges() ;
Standard_EXPORT TColStd_SequenceOfInteger& Vertices();
Standard_EXPORT TColStd_SequenceOfInteger& Vertices() ;
Standard_EXPORT TColStd_SequenceOfInteger& Triangles();
Standard_EXPORT TColStd_SequenceOfInteger& Triangles() ;
Standard_EXPORT void DrawOn(Draw_Display& theDisplay) const;
Standard_EXPORT void DrawOn(Draw_Display& dis) const;
Standard_EXPORT virtual Handle_Draw_Drawable3D Copy() const;
Standard_EXPORT virtual Handle_Draw_Drawable3D Copy() const;
Standard_EXPORT virtual void Dump(Standard_OStream& theStream) const;
Standard_EXPORT virtual void Dump(Standard_OStream& S) const;
Standard_EXPORT virtual void Whatis(Draw_Interpretor& theDi) const;
Standard_EXPORT virtual void Whatis(Draw_Interpretor& S) const;
Standard_EXPORT Handle(BRepMesh_FastDiscret) Mesh() const;
Standard_EXPORT const Handle(BRepMesh_IncrementalMesh)& Mesher() const;
DEFINE_STANDARD_RTTI(MeshTest_DrawableMesh)
private:
Handle(BRepMesh_FastDiscret) myMesh;
Standard_Real myDeflection;
TColStd_SequenceOfInteger myEdges;
TColStd_SequenceOfInteger myVertices;
TColStd_SequenceOfInteger myTriangles;
Standard_Boolean myinshape;
Handle(BRepMesh_IncrementalMesh) myMesher;
Standard_Real myDeflection;
TColStd_SequenceOfInteger myEdges;
TColStd_SequenceOfInteger myVertices;
TColStd_SequenceOfInteger myTriangles;
};
DEFINE_STANDARD_HANDLE(MeshTest_DrawableMesh, Draw_Drawable3D)

2
src/MeshTest/MeshTest_PluginCommands.cxx
View File

@ -23,7 +23,7 @@
#include <BRepMesh_DiscretRoot.hxx>
#include <BRepMesh_IncrementalMesh.hxx>
#include <Bnd_Box.hxx>
#include <BRepMesh_PDiscretRoot.hxx>
#include <BRepMesh_DiscretRoot.hxx>
#include <Draw.hxx>
#include <DBRep.hxx>
#include <TopTools_IndexedMapOfShape.hxx>

2
src/XBRepMesh/FILES Normal file
View File

@ -0,0 +1,2 @@
XBRepMesh.hxx
XBRepMesh.cxx

31
src/XBRepMesh/XBRepMesh.cdl
View File

@ -1,31 +0,0 @@
-- Created on: 2008-04-11
-- Created by: Peter KURNEV
-- Copyright (c) 2008-2014 OPEN CASCADE SAS
--
-- This file is part of Open CASCADE Technology software library.
--
-- This library is free software; you can redistribute it and/or modify it under
-- the terms of the GNU Lesser General Public License version 2.1 as published
-- by the Free Software Foundation, with special exception defined in the file
-- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-- distribution for complete text of the license and disclaimer of any warranty.
--
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
package XBRepMesh
---Purpose:
uses
TopoDS,
BRepMesh
is
Discret(theShape : Shape from TopoDS;
theDeflection : Real from Standard;
theAngle : Real from Standard;
theAlgo:out PDiscretRoot from BRepMesh)
returns Integer from Standard;
end XBRepMesh;

11
src/XBRepMesh/XBRepMesh.cxx
View File

@ -13,7 +13,7 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <XBRepMesh.ixx>
#include <XBRepMesh.hxx>
#include <BRepMesh_PluginMacro.hxx>
#include <BRepMesh_IncrementalMesh.hxx>
@ -21,10 +21,11 @@
//function : Discret
//purpose :
//=======================================================================
Standard_Integer XBRepMesh::Discret(const TopoDS_Shape& theShape,
const Standard_Real theDeflection,
const Standard_Real theAngle,
BRepMesh_PDiscretRoot& theAlgo)
Standard_Integer XBRepMesh::Discret(
const TopoDS_Shape& theShape,
const Standard_Real theDeflection,
const Standard_Real theAngle,
BRepMesh_DiscretRoot* &theAlgo)
{
Standard_Integer iErr;
//

39
src/XBRepMesh/XBRepMesh.hxx Normal file
View File

@ -0,0 +1,39 @@
// Created on: 2008-04-11
// Created by: Peter KURNEV
// Copyright (c) 2008-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _XBRepMesh_HeaderFile
#define _XBRepMesh_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Macro.hxx>
#include <BRepMesh_DiscretRoot.hxx>
class TopoDS_Shape;
class XBRepMesh
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT static Standard_Integer Discret(
const TopoDS_Shape& theShape,
const Standard_Real theDeflection,
const Standard_Real theAngle,
BRepMesh_DiscretRoot* &theAlgo);
};
#endif

212
src/XSDRAWSTLVRML/XSDRAWSTLVRML_ToVRML.cxx
View File

@ -19,6 +19,8 @@
#include <BRepMesh_Edge.hxx>
#include <Bnd_Box.hxx>
#include <BRepBndLib.hxx>
#include <TopExp_Explorer.hxx>
#include <TopoDS.hxx>
#include <gp_Pnt.hxx> //ied_modif_for_compil_Nov-20-1998
@ -63,103 +65,141 @@ Standard_Real& XSDRAWSTLVRML_ToVRML::Deflection () { return myDeflecti
//=======================================================================
Standard_Boolean XSDRAWSTLVRML_ToVRML::Write
(const TopoDS_Shape& aShape, const Standard_CString filename) const
(const TopoDS_Shape& theShape, const Standard_CString theFileName) const
{
filebuf thefile;
ostream TheFileOut(&thefile);
filebuf aFile;
ostream anOut(&aFile);
if (thefile.open(filename,ios::out))
{
if ( aFile.open(theFileName,ios::out) )
{
// Creates facets from the shape
// Create (defle : Real from Standard;
// shape : Shape from TopoDS;
// angl : Real from Standard = 0.17;
// withShare : Boolean from Standard = Standard_True;
// inshape : Boolean from Standard = Standard_False;
// relative : Boolean from Standard = Standard_False;
// shapetrigu: Boolean from Standard = Standard_False)
// returns mutable Discret from BRepMesh;
// Creates facets from the shape
// Create (defle : Real from Standard;
// shape : Shape from TopoDS;
// angl : Real from Standard= 0.17;
// withShare : Boolean from Standard=Standard_True;
// inshape : Boolean from Standard=Standard_False;
// relative : Boolean from Standard=Standard_False;
// shapetrigu: Boolean from Standard=Standard_False)
// returns mutable Discret from BRepMesh;
Bnd_Box B;
BRepBndLib::Add(aShape, B);
Bnd_Box aBox;
BRepBndLib::Add(theShape, aBox);
Handle(BRepMesh_FastDiscret) TheDiscret =
new BRepMesh_FastDiscret(aShape,
myDeflection,
0.17,
B,
Standard_True,
Standard_False,
Standard_True,
Standard_True);
Handle(BRepMesh_FastDiscret) aDiscret =
new BRepMesh_FastDiscret( theShape,
myDeflection,
0.17,
aBox,
Standard_True,
Standard_False,
Standard_True,
Standard_True );
Standard_Integer i,j;
// Header of the VRML file
anOut << "#VRML V2.0 utf8" << endl;
anOut << "Group {" << endl;
anOut << " children [ " << endl;
anOut << " NavigationInfo {" << endl;
anOut << " type \"EXAMINE\" " << endl;
anOut << " }," << endl;
anOut << " Shape {" << endl;
// header of the VRML file
TheFileOut << "#VRML V2.0 utf8" << endl;
TheFileOut << "Group {" << endl;
TheFileOut << " children [ " << endl;
TheFileOut << " NavigationInfo {" << endl;
TheFileOut << " type \"EXAMINE\" " << endl;
TheFileOut << " }," << endl;
TheFileOut << "Shape {" << endl;
anOut << " appearance Appearance {" << endl;
anOut << " texture ImageTexture {" << endl;
anOut << " url " << myTexture.ToCString() << endl;
anOut << " }" << endl;
anOut << " material Material {" << endl;
anOut << " diffuseColor " << myDiffuseColorRed << " "
<< myDiffuseColorGreen << " "
<< myDiffuseColorBlue << " " << endl;
anOut << " emissiveColor " << myEmissiveColorRed << " "
<< myEmissiveColorGreen << " "
<< myEmissiveColorBlue << " " << endl;
anOut << " transparency " << myTransparency << endl;
anOut << " ambientIntensity " << myAmbientIntensity << " " << endl;
anOut << " specularColor " << mySpecularColorRed << " "
<< mySpecularColorGreen << " "
<< mySpecularColorBlue << " " << endl;
anOut << " shininess " << myShininess << " " << endl;
anOut << " }" << endl;
anOut << " }" << endl;
TheFileOut << " appearance Appearance {" << endl;
TheFileOut << " texture ImageTexture {" << endl;
TheFileOut << " url " << myTexture.ToCString() << endl;
TheFileOut << " }" << endl;
TheFileOut << " material Material { " << endl;
TheFileOut << " diffuseColor " << myDiffuseColorRed << " " << myDiffuseColorGreen << " " << myDiffuseColorBlue << " " << endl;
TheFileOut << " emissiveColor " << myEmissiveColorRed << " "
<< myEmissiveColorGreen << " " << myEmissiveColorBlue << " " << endl;
TheFileOut << " transparency " << myTransparency << endl;
TheFileOut << " ambientIntensity " << myAmbientIntensity << " " << endl;
TheFileOut << " specularColor " << mySpecularColorRed << " " << mySpecularColorGreen << " " << mySpecularColorBlue << " " << endl;
TheFileOut << " shininess " <<myShininess << " " << endl;
TheFileOut << " }" << endl;
TheFileOut << " }" << endl;
anOut << " geometry IndexedFaceSet {" << endl;
anOut << " coord Coordinate {" << endl;
anOut << " point [" << endl;
TheFileOut << " geometry IndexedFaceSet {" << endl;
TheFileOut << " coord Coordinate {" << endl;
TheFileOut << " point [" << endl;
// puts the coordinates of all the vertices using the order
// Puts the coordinates of all the vertices using the order
// given during the discretisation
for (i=1;i<=TheDiscret->NbVertices();i++)
{
gp_Pnt TheVertex=TheDiscret->Pnt(i);
TheFileOut << " "
<< TheVertex.Coord().X() << " "
<< TheVertex.Coord().Y() << " "
<< TheVertex.Coord().Z() << "," << endl;
}
TheFileOut << " ]" << endl;
TheFileOut << " }" << endl;
TheFileOut << " coordIndex [" << endl;
// retrieves all the triangles in order to draw the facets
for (j=1; j <= TheDiscret->NbTriangles(); j++)
{
Standard_Integer v[3];
TheDiscret->TriangleNodes(j, v);
TheFileOut << " " << v[0]-1 << ", " << v[1]-1 << ", " << v[2]-1 << ", -1, " << endl;
}
TheFileOut << " ]" << endl;
TheFileOut << " solid FALSE" << endl; // it is not a closed solid
TheFileOut << " creaseAngle " << myCreaseAngle << " " << endl; // for smooth shading
TheFileOut << " }" << endl;
TheFileOut << " }" << endl;
TheFileOut << " ]" << endl;
TheFileOut << "} " << endl;
}
else return Standard_False; // failure when opening file
TopExp_Explorer aFaceIt(theShape, TopAbs_FACE);
for (; aFaceIt.More(); aFaceIt.Next())
{
Handle(BRepMesh_FaceAttribute) anAttribute;
const TopoDS_Face& aFace = TopoDS::Face(aFaceIt.Current());
if (!aDiscret->GetFaceAttribute(aFace, anAttribute) || !anAttribute->IsValid())
continue;
thefile.close();
Handle(BRepMesh_DataStructureOfDelaun)& aStructure =
anAttribute->ChangeStructure();
const Standard_Integer aNbVertices = aStructure->NbNodes();
for (Standard_Integer i = 1; i <= aNbVertices; ++i)
{
const BRepMesh_Vertex& aVertex = aStructure->GetNode(i);
const gp_Pnt& aPoint = anAttribute->GetPoint(aVertex);
anOut << " "
<< aPoint.Coord().X() << " "
<< aPoint.Coord().Y() << " "
<< aPoint.Coord().Z() << "," << endl;
}
}
anOut << " ]" << endl;
anOut << " }" << endl;
anOut << " coordIndex [" << endl;
// Retrieves all the triangles in order to draw the facets
for (aFaceIt.Init(theShape, TopAbs_FACE); aFaceIt.More(); aFaceIt.Next())
{
Handle(BRepMesh_FaceAttribute) anAttribute;
const TopoDS_Face& aFace = TopoDS::Face(aFaceIt.Current());
if (!aDiscret->GetFaceAttribute(aFace, anAttribute) || !anAttribute->IsValid())
continue;
Handle(BRepMesh_DataStructureOfDelaun)& aStructure =
anAttribute->ChangeStructure();
const Standard_Integer aNbTriangles = aStructure->NbElements();
for ( Standard_Integer i = 1; i <= aNbTriangles; ++i )
{
const BRepMesh_Triangle& aTriangle = aStructure->GetElement(i);
Standard_Integer v[3];
aStructure->ElementNodes(aTriangle, v);
anOut << " "
<< v[0] - 1 << ", "
<< v[1] - 1 << ", "
<< v[2] - 1 << ", -1," << endl;
}
}
anOut << " ]" << endl;
anOut << " solid FALSE" << endl; // it is not a closed solid
anOut << " creaseAngle " << myCreaseAngle << " " << endl; // for smooth shading
anOut << " }" << endl;
anOut << " }" << endl;
anOut << " ]" << endl;
anOut << "}" << endl;
}
else
{
// Failure when opening file
return Standard_False;
}
aFile.close();
return Standard_True;
}

29
tests/bugs/mesh/bug23106 Executable file
View File

@ -0,0 +1,29 @@
puts "========"
puts "OCC23106"
puts "========"
puts ""
###########################################
## BRepMesh_IncrementalMesh returns wrong status
###########################################
set BugNumber OCC23106
restore [locate_data_file bug23106_face_0triangles.brep] result
incmesh result 0.01
triangles result
set tri 0
set nod 0
set tri_info [trinfo result]
regexp { +([-0-9.+eE]+) +triangles} $tri_info full tri
regexp { +([-0-9.+eE]+) +nodes} $tri_info full nod
if { ${tri} > 0 && ${nod} > 0 } {
puts "${BugNumber} shading: OK"
} else {
puts "${BugNumber} shading: Faulty"
}
set 3dviewer 1