mirror of
https://github.com/Open-Cascade-SAS/OCCT.git
synced 2026-08-25 20:05:43 +08:00
oan
ceb418e13f
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.
425 lines
13 KiB
C++
425 lines
13 KiB
C++
// Created on: 2014-06-03
|
|
// Created by: Oleg AGASHIN
|
|
// Copyright (c) 1997-1999 Matra Datavision
|
|
// Copyright (c) 1999-2014 OPEN CASCADE SAS
|
|
//
|
|
// This file is part of Open CASCADE Technology software library.
|
|
//
|
|
// This 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_WireChecker.hxx>
|
|
|
|
#include <Precision.hxx>
|
|
#include <TColStd_Array1OfInteger.hxx>
|
|
#include <gp_Pnt2d.hxx>
|
|
#include <BRepTools_WireExplorer.hxx>
|
|
#include <TopAbs_Orientation.hxx>
|
|
#include <TopoDS.hxx>
|
|
#include <TopExp_Explorer.hxx>
|
|
#include <Poly_PolygonOnTriangulation.hxx>
|
|
#include <BRepMesh_PairOfPolygon.hxx>
|
|
#include <TColStd_SequenceOfInteger.hxx>
|
|
#include <TColStd_IndexedMapOfInteger.hxx>
|
|
#include <BRepMesh_DataStructureOfDelaun.hxx>
|
|
#include <BRepMesh_Classifier.hxx>
|
|
#include <BRepMesh_WireInterferenceChecker.hxx>
|
|
|
|
#ifdef HAVE_TBB
|
|
// paralleling using Intel TBB
|
|
#include <tbb/parallel_for.h>
|
|
#include <tbb/blocked_range.h>
|
|
#endif
|
|
|
|
//=======================================================================
|
|
//function : Selector::Constructor
|
|
//purpose :
|
|
//=======================================================================
|
|
BRepMesh_WireChecker::BndBox2dTreeSelector::BndBox2dTreeSelector(
|
|
const Standard_Integer theReservedSize)
|
|
: mySkippedIndex(-1),
|
|
myIndices(0, theReservedSize - 1),
|
|
myIndicesNb(0)
|
|
{
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : Reject
|
|
//purpose :
|
|
//=======================================================================
|
|
Standard_Boolean BRepMesh_WireChecker::BndBox2dTreeSelector::Reject(
|
|
const Bnd_Box2d& theBox2D) const
|
|
{
|
|
return myBox2D.IsOut(theBox2D);
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : Accept
|
|
//purpose :
|
|
//=======================================================================
|
|
Standard_Boolean BRepMesh_WireChecker::BndBox2dTreeSelector::Accept(
|
|
const Standard_Integer& theIndex)
|
|
{
|
|
if (theIndex <= mySkippedIndex)
|
|
return Standard_False;
|
|
|
|
myIndices(myIndicesNb++) = theIndex;
|
|
return Standard_True;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : Clear
|
|
//purpose :
|
|
//=======================================================================
|
|
void BRepMesh_WireChecker::BndBox2dTreeSelector::Clear()
|
|
{
|
|
mySkippedIndex = -1;
|
|
myIndicesNb = 0;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : SetBox
|
|
//purpose :
|
|
//=======================================================================
|
|
void BRepMesh_WireChecker::BndBox2dTreeSelector::SetBox(
|
|
const Bnd_Box2d& theBox2D)
|
|
{
|
|
myBox2D = theBox2D;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : Clear
|
|
//purpose :
|
|
//=======================================================================
|
|
void BRepMesh_WireChecker::BndBox2dTreeSelector::SetSkippedIndex(
|
|
const Standard_Integer theIndex)
|
|
{
|
|
mySkippedIndex = theIndex;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : Indices
|
|
//purpose :
|
|
//=======================================================================
|
|
const BRepMeshCol::Array1OfInteger&
|
|
BRepMesh_WireChecker::BndBox2dTreeSelector::Indices() const
|
|
{
|
|
return myIndices;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : IndicesNb
|
|
//purpose :
|
|
//=======================================================================
|
|
Standard_Integer BRepMesh_WireChecker::BndBox2dTreeSelector::IndicesNb() const
|
|
{
|
|
return myIndicesNb;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : Constructor
|
|
//purpose :
|
|
//=======================================================================
|
|
BRepMesh_WireChecker::BRepMesh_WireChecker(
|
|
const TopoDS_Face& theFace,
|
|
const Standard_Real theTolUV,
|
|
const BRepMeshCol::HDMapOfShapePairOfPolygon& theEdges,
|
|
const BRepMeshCol::HIMapOfInteger& theVertexMap,
|
|
const Handle(BRepMesh_DataStructureOfDelaun)& theStructure,
|
|
const Standard_Real theUmin,
|
|
const Standard_Real theUmax,
|
|
const Standard_Real theVmin,
|
|
const Standard_Real theVmax,
|
|
const Standard_Boolean isInParallel)
|
|
: myTolUV(theTolUV),
|
|
myEdges(theEdges),
|
|
myVertexMap(theVertexMap),
|
|
myStructure(theStructure),
|
|
myUmin(theUmin),
|
|
myUmax(theUmax),
|
|
myVmin(theVmin),
|
|
myVmax(theVmax),
|
|
myStatus(BRepMesh_NoError),
|
|
myIsInParallel(isInParallel)
|
|
{
|
|
TopoDS_Face aFace = theFace;
|
|
aFace.Orientation(TopAbs_FORWARD);
|
|
|
|
TopExp_Explorer aFaceExplorer(aFace, TopAbs_WIRE);
|
|
for (; aFaceExplorer.More(); aFaceExplorer.Next())
|
|
{
|
|
const TopoDS_Wire& aWire = TopoDS::Wire(aFaceExplorer.Current());
|
|
|
|
myWiresEdges.push_back(ListOfEdges());
|
|
ListOfEdges& aEdges = myWiresEdges.back();
|
|
|
|
// Start traversing the wires
|
|
BRepTools_WireExplorer aWireExplorer(aWire, aFace);
|
|
for (; aWireExplorer.More(); aWireExplorer.Next())
|
|
{
|
|
const TopoDS_Edge& aEdge = aWireExplorer.Current();
|
|
TopAbs_Orientation aOrient = aEdge.Orientation();
|
|
if (aOrient != TopAbs_FORWARD && aOrient != TopAbs_REVERSED)
|
|
continue;
|
|
|
|
aEdges.Append(aEdge);
|
|
}
|
|
|
|
if (aEdges.IsEmpty())
|
|
myWiresEdges.pop_back();
|
|
}
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : ReCompute
|
|
//purpose :
|
|
//=======================================================================
|
|
void BRepMesh_WireChecker::ReCompute(BRepMeshCol::HClassifier& theClassifier)
|
|
{
|
|
if (theClassifier.IsNull())
|
|
return;
|
|
|
|
theClassifier->Destroy();
|
|
myStatus = BRepMesh_NoError;
|
|
|
|
SeqOfDWires aDWires;
|
|
if (!collectDiscretizedWires(aDWires))
|
|
return;
|
|
|
|
const Standard_Integer aNbWires = (Standard_Integer)aDWires.size();
|
|
|
|
BRepMeshCol::Array1OfSegmentsTree aWiresBiPoints(aNbWires);
|
|
fillSegmentsTree(aDWires, aWiresBiPoints);
|
|
|
|
#ifdef HAVE_TBB
|
|
Standard_Mutex aWireMutex;
|
|
BRepMesh_WireInterferenceChecker aIntChecker(aWiresBiPoints,
|
|
&myStatus, &aWireMutex);
|
|
|
|
if (myIsInParallel && aNbWires > 1)
|
|
{
|
|
// check wires in parallel threads using TBB
|
|
tbb::parallel_for(tbb::blocked_range<Standard_Integer>(0, aNbWires),
|
|
aIntChecker);
|
|
}
|
|
else
|
|
{
|
|
#else
|
|
BRepMesh_WireInterferenceChecker aIntChecker(aWiresBiPoints, &myStatus);
|
|
#endif
|
|
for (Standard_Integer i = 0; i < aNbWires; ++i)
|
|
aIntChecker(i);
|
|
#ifdef HAVE_TBB
|
|
}
|
|
#endif
|
|
|
|
if (myStatus == BRepMesh_SelfIntersectingWire)
|
|
return;
|
|
|
|
// Find holes
|
|
SeqOfDWires::iterator aDWiresIt = aDWires.begin();
|
|
for (; aDWiresIt != aDWires.end(); ++aDWiresIt)
|
|
{
|
|
const SeqOfPnt2d& aDWire = *aDWiresIt;
|
|
theClassifier->RegisterWire(aDWire, myTolUV, myUmin, myUmax, myVmin, myVmax);
|
|
}
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : collectDiscretizedWires
|
|
//purpose :
|
|
//=======================================================================
|
|
Standard_Boolean BRepMesh_WireChecker::collectDiscretizedWires(
|
|
SeqOfDWires& theDWires)
|
|
{
|
|
// TODO: Collect disretized wires in parallel
|
|
SeqOfWireEdges::iterator aWireIt = myWiresEdges.begin();
|
|
for(; aWireIt != myWiresEdges.end(); ++aWireIt)
|
|
{
|
|
const ListOfEdges& aEdges = *aWireIt;
|
|
// For each wire we create a data map, linking vertices (only
|
|
// the ends of edges) with their positions in the sequence of
|
|
// all 2d points from this wire.
|
|
// When we meet some vertex for the second time - the piece
|
|
// of sequence is treated for a HOLE and quits the sequence.
|
|
// Actually, we must unbind the vertices belonging to the
|
|
// loop from the map, but since they can't appear twice on the
|
|
// valid wire, leave them for a little speed up.
|
|
|
|
SeqOfPnt2d aSeqPnt2d;
|
|
DataMapIntInt aNodeInSeq;
|
|
Standard_Integer aFirstIndex = 0, aLastIndex = 0;
|
|
|
|
// Start traversing the wire
|
|
ListOfEdges::Iterator aEdgeIt(aEdges);
|
|
for (; aEdgeIt.More(); aEdgeIt.Next())
|
|
{
|
|
const TopoDS_Edge& aEdge = aEdgeIt.Value();
|
|
TopAbs_Orientation aOrient = aEdge.Orientation();
|
|
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);
|
|
Handle(Poly_PolygonOnTriangulation) aNOD;
|
|
if (aOrient == TopAbs_FORWARD)
|
|
{
|
|
aNOD = aPair.First();
|
|
aStartId = 1;
|
|
aEndId = aNOD->NbNodes();
|
|
aIncrement = 1;
|
|
}
|
|
else
|
|
{
|
|
aNOD = aPair.Last();
|
|
aStartId = aNOD->NbNodes();
|
|
aEndId = 1;
|
|
aIncrement = -1;
|
|
}
|
|
|
|
const TColStd_Array1OfInteger& aIndices = aNOD->Nodes();
|
|
const Standard_Integer aFirstVertexId = myVertexMap->FindKey(aIndices(aStartId));
|
|
const Standard_Integer aLastVertexId = myVertexMap->FindKey(aIndices(aEndId) );
|
|
|
|
if (aFirstVertexId == aLastVertexId && (aEndId - aStartId) == aIncrement)
|
|
{
|
|
// case of continuous set of degenerated edges
|
|
aLastIndex = aLastVertexId;
|
|
continue;
|
|
}
|
|
|
|
if (aFirstIndex != 0)
|
|
{
|
|
if (aFirstVertexId != aLastIndex)
|
|
{
|
|
// there's a gap between edges
|
|
myStatus = BRepMesh_OpenWire;
|
|
return Standard_False;
|
|
}
|
|
}
|
|
else
|
|
aFirstIndex = aFirstVertexId;
|
|
|
|
aLastIndex = aLastVertexId;
|
|
|
|
// Record first vertex (to detect loops)
|
|
aNodeInSeq.Bind(aFirstVertexId, (aSeqPnt2d.Length() + 1));
|
|
|
|
// Add vertices in sequence
|
|
for (Standard_Integer i = aStartId; i != aEndId; i += aIncrement)
|
|
{
|
|
Standard_Integer aIndex = ((i == aStartId) ?
|
|
aFirstVertexId :
|
|
myVertexMap->FindKey(aIndices(i)));
|
|
|
|
aSeqPnt2d.Append(gp_Pnt2d(myStructure->GetNode(aIndex).Coord()));
|
|
}
|
|
|
|
// Now, is there a loop?
|
|
if (aNodeInSeq.IsBound(aLastVertexId))
|
|
{
|
|
// Yes, treat it separately as a hole
|
|
// Divide points into main wire and a loop
|
|
const Standard_Integer aIdxWireStart = aNodeInSeq(aLastVertexId);
|
|
if(aIdxWireStart < aSeqPnt2d.Length())
|
|
{
|
|
theDWires.push_back(SeqOfPnt2d());
|
|
SeqOfPnt2d& aWire = theDWires.back();
|
|
aSeqPnt2d.Split(aIdxWireStart, aWire);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (aFirstIndex == 0)
|
|
continue;
|
|
|
|
// Isn't wire open?
|
|
if (aFirstIndex != aLastIndex || aSeqPnt2d.Length() > 1)
|
|
{
|
|
myStatus = BRepMesh_OpenWire;
|
|
return Standard_False;
|
|
}
|
|
}
|
|
|
|
return Standard_True;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : fillSegmentsTree
|
|
//purpose :
|
|
//=======================================================================
|
|
void BRepMesh_WireChecker::fillSegmentsTree(
|
|
const SeqOfDWires& theDWires,
|
|
BRepMeshCol::Array1OfSegmentsTree& theWiresSegmentsTree)
|
|
{
|
|
const size_t aNbWires = theDWires.size();
|
|
for (size_t aWireIt = 0; aWireIt < aNbWires; ++aWireIt)
|
|
{
|
|
const SeqOfPnt2d& aWire = theDWires[aWireIt];
|
|
const Standard_Integer aWireLen = aWire.Size();
|
|
|
|
BRepMeshCol::HArray1OfSegments aWireSegments =
|
|
new BRepMeshCol::Array1OfSegments(aWireLen);
|
|
|
|
BRepMeshCol::HBndBox2dTree aBndBoxTree =
|
|
new BRepMeshCol::BndBox2dTree;
|
|
|
|
BRepMeshCol::BndBox2dTreeFiller aBndBoxTreeFiller(*aBndBoxTree);
|
|
|
|
Standard_Real x1 = 0., y1 = 0., aXstart = 0., aYstart = 0.;
|
|
for (Standard_Integer aPntIt = 0; aPntIt <= aWireLen; ++aPntIt)
|
|
{
|
|
Standard_Real x2, y2;
|
|
// Obtain last point of the segment
|
|
if (aPntIt == aWireLen)
|
|
{
|
|
x2 = aXstart;
|
|
y2 = aYstart;
|
|
}
|
|
else
|
|
{
|
|
const gp_Pnt2d& aPnt = aWire(aPntIt + 1);
|
|
x2 = aPnt.X();
|
|
y2 = aPnt.Y();
|
|
}
|
|
|
|
// Build segment (bi-point)
|
|
if (aPntIt == 0)
|
|
{
|
|
aXstart = x2;
|
|
aYstart = y2;
|
|
}
|
|
else
|
|
{
|
|
gp_Pnt2d aStartPnt(x1, y1);
|
|
gp_Pnt2d aEndPnt(x2, y2);
|
|
|
|
const Standard_Integer aPointId = aPntIt - 1;
|
|
BRepMeshCol::Segment& aSegment = aWireSegments->at(aPointId);
|
|
aSegment.StartPnt = aStartPnt.XY();
|
|
aSegment.EndPnt = aEndPnt.XY();
|
|
|
|
Bnd_Box2d aBox;
|
|
aBox.Add(aStartPnt);
|
|
aBox.Add( aEndPnt);
|
|
aBndBoxTreeFiller.Add(aPointId, aBox);
|
|
}
|
|
x1 = x2;
|
|
y1 = y2;
|
|
}
|
|
aBndBoxTreeFiller.Fill();
|
|
|
|
BRepMeshCol::SegmentsTree& aSegmentsTree = theWiresSegmentsTree[aWireIt];
|
|
aSegmentsTree.first = aWireSegments;
|
|
aSegmentsTree.second = aBndBoxTree;
|
|
}
|
|
}
|