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
occt/src/BOPTools/BOPTools_AlgoTools.hxx
dpasukhi 604c3b890c Documentation - Update parameter annotations for consistency #161 
Reorganized style for param to the next templates:
 - "@param theParameter description ..."
 - "@param[in] theParameter description ..."
 - "@param[out] theParameter description ..."
 - "@param[in][out] theParameter description ..."
 The replacement was with keeping spacing, no removing of extra spaces.
In some files '/' was used instead of '@', that was not updated yet.
2024-11-17 20:22:51 +00:00

587 lines
30 KiB
C++
Raw Blame History

// Created by: Peter KURNEV
// Copyright (c) 2010-2014 OPEN CASCADE SAS
// Copyright (c) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE
// Copyright (c) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, CEDRAT,
// EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// 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 _BOPTools_AlgoTools_HeaderFile
#define _BOPTools_AlgoTools_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Real.hxx>
#include <BOPTools_ListOfCoupleOfShape.hxx>
#include <BOPTools_ListOfConnexityBlock.hxx>
#include <NCollection_BaseAllocator.hxx>
#include <TopAbs_State.hxx>
#include <TopAbs_ShapeEnum.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
#include <TopTools_MapOfShape.hxx>
#include <TopTools_ListOfListOfShape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <Precision.hxx>
class TopoDS_Vertex;
class gp_Pnt;
class IntTools_Curve;
class TopoDS_Edge;
class TopoDS_Face;
class TopoDS_Shape;
class IntTools_Context;
class TopoDS_Solid;
class IntTools_Range;
class TopoDS_Shell;
class Message_Report;
//! Provides tools used in Boolean Operations algorithm:
//! - Vertices intersection;
//! - Vertex construction;
//! - Edge construction;
//! - Classification algorithms;
//! - Making connexity blocks;
//! - Shape validation.
class BOPTools_AlgoTools
{
public:
DEFINE_STANDARD_ALLOC
public: //! @name Constants
//! Additional tolerance (delta tolerance) is used in Boolean Operations
//! to ensure that the tolerance of new/old entities obtained
//! by intersection of two shapes is slightly bigger than the actual
//! distances to these shapes. It helps to avoid numerical instability
//! which may occur when comparing distances and tolerances.
static Standard_Real DTolerance() { return 1.e-12; }
public: //! @name Intersection of the vertices
//! Intersects the vertex <theV1> with the point <theP> with tolerance <theTolP>.
//! Returns the error status:
//! - 0 - no error, meaning that the vertex intersects the point;
//! - 1 - the distance between vertex and point is grater than the sum of tolerances.
Standard_EXPORT static Standard_Integer ComputeVV(const TopoDS_Vertex& theV,
const gp_Pnt& theP,
const Standard_Real theTolP);
//! Intersects the given vertices with given fuzzy value.
//! Returns the error status:
//! - 0 - no error, meaning that the vertices interferes with given tolerance;
//! - 1 - the distance between vertices is grater than the sum of their tolerances.
Standard_EXPORT static Standard_Integer ComputeVV(const TopoDS_Vertex& theV1,
const TopoDS_Vertex& theV2,
const Standard_Real theFuzz = Precision::Confusion());
public: //! @name Vertices construction
//! Makes the vertex in the middle of given vertices with
//! the tolerance covering all tolerance spheres of vertices.
Standard_EXPORT static void MakeVertex(const TopTools_ListOfShape& theLV,
TopoDS_Vertex& theV);
//! Make a vertex using 3D-point <aP1> and 3D-tolerance value <aTol>
Standard_EXPORT static void MakeNewVertex(const gp_Pnt& aP1,
const Standard_Real aTol,
TopoDS_Vertex& aNewVertex);
//! Make a vertex using couple of vertices <aV1, aV2>
Standard_EXPORT static void MakeNewVertex(const TopoDS_Vertex& aV1,
const TopoDS_Vertex& aV2,
TopoDS_Vertex& aNewVertex);
//! Make a vertex in place of intersection between two edges
//! <aE1, aE2> with parameters <aP1, aP2>
Standard_EXPORT static void MakeNewVertex(const TopoDS_Edge& aE1,
const Standard_Real aP1,
const TopoDS_Edge& aE2,
const Standard_Real aP2,
TopoDS_Vertex& aNewVertex);
//! Make a vertex in place of intersection between the edge <aE1>
//! with parameter <aP1> and the face <aF2>
Standard_EXPORT static void MakeNewVertex(const TopoDS_Edge& aE1,
const Standard_Real aP1,
const TopoDS_Face& aF2,
TopoDS_Vertex& aNewVertex);
public: //! @name Updating the vertex
//! Update the tolerance value for vertex <aV>
//! taking into account the fact that <aV> lays on
//! the curve <aIC>
Standard_EXPORT static void UpdateVertex(const IntTools_Curve& aIC,
const Standard_Real aT,
const TopoDS_Vertex& aV);
//! Update the tolerance value for vertex <aV>
//! taking into account the fact that <aV> lays on
//! the edge <aE>
Standard_EXPORT static void UpdateVertex(const TopoDS_Edge& aE,
const Standard_Real aT,
const TopoDS_Vertex& aV);
//! Update the tolerance value for vertex <aVN>
//! taking into account the fact that <aVN> should
//! cover tolerance zone of <aVF>
Standard_EXPORT static void UpdateVertex(const TopoDS_Vertex& aVF,
const TopoDS_Vertex& aVN);
public: //! @name Edge construction
//! Makes the edge based on the given curve with given bounding vertices.
Standard_EXPORT static void MakeEdge(const IntTools_Curve& theCurve,
const TopoDS_Vertex& theV1,
const Standard_Real theT1,
const TopoDS_Vertex& theV2,
const Standard_Real theT2,
const Standard_Real theTolR3D,
TopoDS_Edge& theE);
//! Makes a copy of <theEdge> with vertices.
Standard_EXPORT static TopoDS_Edge CopyEdge(const TopoDS_Edge& theEdge);
//! Make the edge from base edge <aE1> and two vertices <aV1,aV2>
//! at parameters <aP1,aP2>
Standard_EXPORT static void MakeSplitEdge(const TopoDS_Edge& aE1,
const TopoDS_Vertex& aV1,
const Standard_Real aP1,
const TopoDS_Vertex& aV2,
const Standard_Real aP2,
TopoDS_Edge& aNewEdge);
//! Make the edge from 3D-Curve <aIC> and two vertices <aV1,aV2>
//! at parameters <aP1,aP2>
Standard_EXPORT static void MakeSectEdge(const IntTools_Curve& aIC,
const TopoDS_Vertex& aV1,
const Standard_Real aP1,
const TopoDS_Vertex& aV2,
const Standard_Real aP2,
TopoDS_Edge& aNewEdge);
public: //! @name Point/Edge/Face classification relatively solid
//! Computes the 3-D state of the point thePoint
//! toward solid theSolid.
//! theTol - value of precision of computation
//! theContext- cached geometrical tools
//! Returns 3-D state.
Standard_EXPORT static TopAbs_State ComputeState(const gp_Pnt& thePoint,
const TopoDS_Solid& theSolid,
const Standard_Real theTol,
const Handle(IntTools_Context)& theContext);
//! Computes the 3-D state of the vertex theVertex
//! toward solid theSolid.
//! theTol - value of precision of computation
//! theContext- cached geometrical tools
//! Returns 3-D state.
Standard_EXPORT static TopAbs_State ComputeState(const TopoDS_Vertex& theVertex,
const TopoDS_Solid& theSolid,
const Standard_Real theTol,
const Handle(IntTools_Context)& theContext);
//! Computes the 3-D state of the edge theEdge
//! toward solid theSolid.
//! theTol - value of precision of computation
//! theContext- cached geometrical tools
//! Returns 3-D state.
Standard_EXPORT static TopAbs_State ComputeState(const TopoDS_Edge& theEdge,
const TopoDS_Solid& theSolid,
const Standard_Real theTol,
const Handle(IntTools_Context)& theContext);
//! Computes the 3-D state of the face theFace
//! toward solid theSolid.
//! theTol - value of precision of computation
//! theBounds - set of edges of <theSolid> to avoid
//! theContext- cached geometrical tools
//! Returns 3-D state.
Standard_EXPORT static TopAbs_State ComputeState(const TopoDS_Face& theFace,
const TopoDS_Solid& theSolid,
const Standard_Real theTol,
const TopTools_IndexedMapOfShape& theBounds,
const Handle(IntTools_Context)& theContext);
//! Computes the 3-D state of the shape theShape
//! toward solid theSolid.
//! theTol - value of precision of computation
//! theContext- cached geometrical tools
//! Returns 3-D state.
Standard_EXPORT static TopAbs_State ComputeStateByOnePoint(const TopoDS_Shape& theShape,
const TopoDS_Solid& theSolid,
const Standard_Real theTol,
const Handle(IntTools_Context)& theContext);
public: //! @name Face classification relatively solid
//! For the face theFace and its edge theEdge
//! finds the face suitable to produce shell.
//! theLCEF - set of faces to search. All faces
//! from theLCEF must share edge theEdge
Standard_EXPORT static Standard_Boolean GetFaceOff(const TopoDS_Edge& theEdge,
const TopoDS_Face& theFace,
BOPTools_ListOfCoupleOfShape& theLCEF,
TopoDS_Face& theFaceOff,
const Handle(IntTools_Context)& theContext);
//! Returns True if the face theFace is inside of the
//! couple of faces theFace1, theFace2.
//! The faces theFace, theFace1, theFace2 must
//! share the edge theEdge
//! Return values:
//! * 0 state is not IN
//! * 1 state is IN
//! * 2 state can not be found by the method of angles
Standard_EXPORT static Standard_Integer IsInternalFace(const TopoDS_Face& theFace,
const TopoDS_Edge& theEdge,
const TopoDS_Face& theFace1,
const TopoDS_Face& theFace2,
const Handle(IntTools_Context)& theContext);
//! Returns True if the face theFace is inside of the
//! appropriate couple of faces (from the set theLF) .
//! The faces of the set theLF and theFace must
//! share the edge theEdge
//! * 0 state is not IN
//! * 1 state is IN
//! * 2 state can not be found by the method of angles
Standard_EXPORT static Standard_Integer IsInternalFace(const TopoDS_Face& theFace,
const TopoDS_Edge& theEdge,
TopTools_ListOfShape& theLF,
const Handle(IntTools_Context)& theContext);
//! Returns True if the face theFace is inside the
//! solid theSolid.
//! theMEF - Map Edge/Faces for theSolid
//! theTol - value of precision of computation
//! theContext- cached geometrical tools
Standard_EXPORT static Standard_Boolean IsInternalFace(const TopoDS_Face& theFace,
const TopoDS_Solid& theSolid,
TopTools_IndexedDataMapOfShapeListOfShape& theMEF,
const Standard_Real theTol,
const Handle(IntTools_Context)& theContext);
public: //! @name PCurve construction
//! Makes 2d curve of the edge <theE> on the faces <theF1> and <theF2>.<br>
//! <theContext> - storage for caching the geometrical tools
Standard_EXPORT static void MakePCurve (const TopoDS_Edge& theE,
const TopoDS_Face& theF1,
const TopoDS_Face& theF2,
const IntTools_Curve& theCurve,
const Standard_Boolean thePC1,
const Standard_Boolean thePC2,
const Handle(IntTools_Context)& theContext = Handle(IntTools_Context)());
public: //! @name Wire classification relatively face
//! Checks if the wire is a hole for the face.
Standard_EXPORT static Standard_Boolean IsHole(const TopoDS_Shape& theW,
const TopoDS_Shape& theF);
public: //! @name Choosing correct orientation for the split shape
//! Checks if the direction of the split shape is opposite to
//! the direction of the original shape.
//! The method is an overload for (Edge,Edge) and (Face,Face) corresponding
//! methods and checks only these types of shapes.
//! For faces the method checks if normal directions are opposite.
//! For edges the method checks if tangent vectors are opposite.
//!
//! In case the directions do not coincide, it returns TRUE, meaning
//! that split shape has to be reversed to match the direction of the
//! original shape.
//!
//! If requested (<theError> is not null), the method returns the status of the operation:
//! - 0 - no error;
//! - Error from (Edge,Edge) or (Face,Face) corresponding method
//! - 100 - bad types.
//! In case of any error the method always returns FALSE.
//!
//! @param[in] theSplit Split shape
//! @param[in] theShape Original shape
//! @param[in] theContext cached geometrical tools
//! @param[out] theError Error Status of the operation
Standard_EXPORT static Standard_Boolean IsSplitToReverse(const TopoDS_Shape& theSplit,
const TopoDS_Shape& theShape,
const Handle(IntTools_Context)& theContext,
Standard_Integer *theError = NULL);
//! Add-on for the *IsSplitToReverse()* to check for its errors
//! and in case of any add the *BOPAlgo_AlertUnableToOrientTheShape*
//! warning to the report.
Standard_EXPORT static Standard_Boolean IsSplitToReverseWithWarn(const TopoDS_Shape& theSplit,
const TopoDS_Shape& theShape,
const Handle(IntTools_Context)& theContext,
const Handle(Message_Report)& theReport = NULL);
//! Checks if the normal direction of the split face is opposite to
//! the normal direction of the original face.
//! The normal directions for both faces are taken in the same point -
//! point inside the split face is projected onto the original face.
//! Returns TRUE if the normals do not coincide, meaning the necessity
//! to revert the orientation of the split face to match the direction
//! of the original face.
//!
//! If requested (<theError> is not null), the method returns the status of the operation:
//! - 0 - no error;
//! - 1 - unable to find the point inside split face;
//! - 2 - unable to compute the normal for the split face;
//! - 3 - unable to project the point inside the split face on the original face;
//! - 4 - unable to compute the normal for the original face.
//! In case of any error the method always returns FALSE.
//!
//! @param[in] theSplit Split face
//! @param[in] theShape Original face
//! @param[in] theContext cached geometrical tools
//! @param[out] theError Error Status of the operation
Standard_EXPORT static Standard_Boolean IsSplitToReverse(const TopoDS_Face& theSplit,
const TopoDS_Face& theShape,
const Handle(IntTools_Context)& theContext,
Standard_Integer *theError = NULL);
//! Checks if the tangent vector of the split edge is opposite to
//! the tangent vector of the original edge.
//! The tangent vectors for both edges are computed in the same point -
//! point inside the split edge is projected onto the original edge.
//! Returns TRUE if the tangent vectors do not coincide, meaning the necessity
//! to revert the orientation of the split edge to match the direction
//! of the original edge.
//!
//! If requested (<theError> is not null), the method returns the status of the operation:
//! - 0 - no error;
//! - 1 - degenerated edges are given;
//! - 2 - unable to compute the tangent vector for the split edge;
//! - 3 - unable to project the point inside the split edge on the original edge;
//! - 4 - unable to compute the tangent vector for the original edge;
//! In case of any error the method always returns FALSE.
//!
//! @param[in] theSplit Split edge
//! @param[in] theShape Original edge
//! @param[in] theContext cached geometrical tools
//! @param[out] theError Error Status of the operation
Standard_EXPORT static Standard_Boolean IsSplitToReverse(const TopoDS_Edge& theSplit,
const TopoDS_Edge& theShape,
const Handle(IntTools_Context)& theContext,
Standard_Integer *theError = NULL);
//! Checks if the normals direction of the given faces computed near
//! the shared edge coincide.
//! Returns the status of operation:
//! * 0 - in case of error (shared edge not found or directions are not collinear)
//! * 1 - normal directions coincide;
//! * -1 - normal directions are opposite.
Standard_EXPORT static Standard_Integer Sense(const TopoDS_Face& theF1,
const TopoDS_Face& theF2,
const Handle(IntTools_Context)& theContext);
public: //! @name Making connexity blocks
//! For the list of faces theLS build block
//! theLSCB in terms of connexity by edges
//! theMapAvoid - set of edges to avoid for
//! the treatment
Standard_EXPORT static void MakeConnexityBlock(TopTools_ListOfShape& theLS,
TopTools_IndexedMapOfShape& theMapAvoid,
TopTools_ListOfShape& theLSCB,
const Handle(NCollection_BaseAllocator)& theAllocator);
//! For the compound <theS> builds the blocks (compounds) of
//! elements of type <theElementType> connected through the shapes
//! of the type <theConnectionType>.
//! The blocks are stored into the list <theLCB>.
Standard_EXPORT static void MakeConnexityBlocks(const TopoDS_Shape& theS,
const TopAbs_ShapeEnum theConnectionType,
const TopAbs_ShapeEnum theElementType,
TopTools_ListOfShape& theLCB);
//! For the compound <theS> builds the blocks (compounds) of
//! elements of type <theElementType> connected through the shapes
//! of the type <theConnectionType>.
//! The blocks are stored into the list of lists <theLCB>.
//! Returns also the connection map <theConnectionMap>, filled during operation.
Standard_EXPORT static void MakeConnexityBlocks(const TopoDS_Shape& theS,
const TopAbs_ShapeEnum theConnectionType,
const TopAbs_ShapeEnum theElementType,
TopTools_ListOfListOfShape& theLCB,
TopTools_IndexedDataMapOfShapeListOfShape& theConnectionMap);
//! Makes connexity blocks of elements of the given type with the given type of the
//! connecting elements. The blocks are checked on regularity (multi-connectivity)
//! and stored to the list of blocks <theLCB>.
Standard_EXPORT static void MakeConnexityBlocks(const TopTools_ListOfShape& theLS,
const TopAbs_ShapeEnum theConnectionType,
const TopAbs_ShapeEnum theElementType,
BOPTools_ListOfConnexityBlock& theLCB);
public: //! @name Orienting elements in container
//! Correctly orients edges on the wire
Standard_EXPORT static void OrientEdgesOnWire(TopoDS_Shape& theWire);
//! Correctly orients faces on the shell
Standard_EXPORT static void OrientFacesOnShell(TopoDS_Shape& theShell);
public: //! @name Methods for shape validation (correction)
//! Provides valid values of tolerances for the shape <theS>
//! <theTolMax> is max value of the tolerance that can be
//! accepted for correction. If real value of the tolerance
//! will be greater than <aTolMax>, the correction does not
//! perform.
Standard_EXPORT static void CorrectTolerances(const TopoDS_Shape& theS,
const TopTools_IndexedMapOfShape& theMapToAvoid,
const Standard_Real theTolMax = 0.0001,
const Standard_Boolean theRunParallel = Standard_False);
//! Provides valid values of tolerances for the shape <theS>
//! in terms of BRepCheck_InvalidCurveOnSurface.
Standard_EXPORT static void CorrectCurveOnSurface(const TopoDS_Shape& theS,
const TopTools_IndexedMapOfShape& theMapToAvoid,
const Standard_Real theTolMax = 0.0001,
const Standard_Boolean theRunParallel = Standard_False);
//! Provides valid values of tolerances for the shape <theS>
//! in terms of BRepCheck_InvalidPointOnCurve.
Standard_EXPORT static void CorrectPointOnCurve(const TopoDS_Shape& theS,
const TopTools_IndexedMapOfShape& theMapToAvoid,
const Standard_Real theTolMax = 0.0001,
const Standard_Boolean theRunParallel = Standard_False);
//! Corrects tolerance values of the sub-shapes of the shape <theS> if needed.
Standard_EXPORT static void CorrectShapeTolerances(const TopoDS_Shape& theS,
const TopTools_IndexedMapOfShape& theMapToAvoid,
const Standard_Boolean theRunParallel = Standard_False);
public: //! Checking if the faces are coinciding
//! Checks if the given faces are same-domain, i.e. coincide.
Standard_EXPORT static Standard_Boolean AreFacesSameDomain(const TopoDS_Face& theF1,
const TopoDS_Face& theF2,
const Handle(IntTools_Context)& theContext,
const Standard_Real theFuzz = Precision::Confusion());
public: //! @name Looking for the edge in the face
//! Returns True if the face theFace contains
//! the edge theEdge but with opposite orientation.
//! If the method returns True theEdgeOff is the
//! edge founded
Standard_EXPORT static Standard_Boolean GetEdgeOff(const TopoDS_Edge& theEdge,
const TopoDS_Face& theFace,
TopoDS_Edge& theEdgeOff);
//! For the face theFace gets the edge theEdgeOnF
//! that is the same as theEdge
//! Returns True if such edge exists
//! Returns False if there is no such edge
Standard_EXPORT static Standard_Boolean GetEdgeOnFace(const TopoDS_Edge& theEdge,
const TopoDS_Face& theFace,
TopoDS_Edge& theEdgeOnF);
public: //! @name Correction of the edges range
//! Correct shrunk range <aSR> taking into account 3D-curve
//! resolution and corresponding tolerance values of <aE1>, <aE2>
Standard_EXPORT static void CorrectRange(const TopoDS_Edge& aE1,
const TopoDS_Edge& aE2,
const IntTools_Range& aSR,
IntTools_Range& aNewSR);
//! Correct shrunk range <aSR> taking into account 3D-curve
//! resolution and corresponding tolerance values of <aE>, <aF>
Standard_EXPORT static void CorrectRange(const TopoDS_Edge& aE,
const TopoDS_Face& aF,
const IntTools_Range& aSR,
IntTools_Range& aNewSR);
public: //! @name Checking edge on micro status
//! Checks if it is possible to compute shrunk range for the edge <aE>
//! Flag <theCheckSplittable> defines whether to take into account
//! the possibility to split the edge or not.
Standard_EXPORT static Standard_Boolean IsMicroEdge(const TopoDS_Edge& theEdge,
const Handle(IntTools_Context)& theContext,
const Standard_Boolean theCheckSplittable = Standard_True);
public: //! @name Solid classification
//! Returns true if the solid <theSolid> is inverted
Standard_EXPORT static Standard_Boolean IsInvertedSolid(const TopoDS_Solid& theSolid);
public: //! @name Edge/Face Deviation computation
//! Computes the necessary value of the tolerance for the edge
Standard_EXPORT static Standard_Boolean ComputeTolerance(const TopoDS_Face& theFace,
const TopoDS_Edge& theEdge,
Standard_Real& theMaxDist,
Standard_Real& theMaxPar);
public: //! @name Other methods
//! Makes empty container of requested type
Standard_EXPORT static void MakeContainer(const TopAbs_ShapeEnum theType,
TopoDS_Shape& theShape);
//! Compute a 3D-point on the edge <aEdge> at parameter <aPrm>
Standard_EXPORT static void PointOnEdge(const TopoDS_Edge& aEdge,
const Standard_Real aPrm,
gp_Pnt& aP);
//! Returns TRUE if PaveBlock <aPB> lays on the face <aF>, i.e
//! the <PB> is IN or ON in 2D of <aF>
Standard_EXPORT static Standard_Boolean IsBlockInOnFace(const IntTools_Range& aShR,
const TopoDS_Face& aF,
const TopoDS_Edge& aE,
const Handle(IntTools_Context)& aContext);
//! Returns the min and max dimensions of the shape <theS>.
Standard_EXPORT static void Dimensions (const TopoDS_Shape& theS,
Standard_Integer& theDMin,
Standard_Integer& theDMax);
//! Returns dimension of the shape <theS>.
//! If the shape contains elements of different dimension, -1 is returned.
Standard_EXPORT static Standard_Integer Dimension(const TopoDS_Shape& theS);
//! Collects in the output list recursively all non-compound sub-shapes of the first level
//! of the given shape theS. The optional map theMap is used to avoid the duplicates in the
//! output list, so it will also contain all non-compound sub-shapes.
Standard_EXPORT static void TreatCompound (const TopoDS_Shape& theS,
TopTools_ListOfShape& theList,
TopTools_MapOfShape* theMap = NULL);
//! Returns true if the shell <theShell> is open
Standard_EXPORT static Standard_Boolean IsOpenShell(const TopoDS_Shell& theShell);
};
#endif // _BOPTools_AlgoTools_HeaderFile
View Git Blame Copy Permalink