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

0028426: Implementation of the EdgesToFaces function

Browse Source 
1. The two new methods have been implemented:
a. BOPAlgo_Tools::EdgesToWires - allows creating planar wires from edges.
The input edges may be not shared, but the output wires will be sharing the coinciding vertices and edges.
It is possible to skip the sharing if the input edges are already shared by passing the corresponding flag into the method.
The input edges are expected to be planar, but the method does not check it. Thus, if the input edges are not planar, the output wires will also be not planar.
In general, the output wires will be non-manifold and may contain free vertices.

b. BOPAlgo_Tools::WiresToFaces - allows creating planar faces from the planar wires.
In general, the input wires are non-manifold and may be not closed, but should share the coinciding parts.
The wires located in the same plane and completely included into other wires will create holes in the faces built from bigger wires

These two methods combined allow building faces from set of edges randomly located in 3D space.

2. The DRAW command *edgestofaces* has been implemented.

3. The documentation has been updated with the new section in Modeling Algorithms - Topological Tools.

4. Test cases for the issue.
This commit is contained in:
emv 2017-02-03 14:24:28 +03:00 committed by apn
parent ea3193f52e
commit e6ae74fd42
48 changed files with 1716 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
dox/user_guides/draw_test_harness/draw_test_harness.md
View File

@ -7656,6 +7656,19 @@ nurbsconvert result name [result name]
Changes the NURBS curve definition of a shape to a Bspline curve definition. This conversion is required for assymetric deformation and prepares the arguments for other commands such as **deform**. The conversion can be necessary when transferring shape data to other applications.
@subsubsection occt_draw_7_11_6 edgestofaces
**edgestofaces** - The command allows building planar faces from the planar edges randomly located in 3D space.
It has the following syntax:
~~~~
edgestofaces r_faces edges [-a AngTol -s Shared(0/1)]
~~~~
Options:
* -a AngTol - angular tolerance used for distinguishing the planar faces;
* -s Shared(0/1) - boolean flag which defines whether the input edges are already shared or have to be intersected.
@subsection occt_draw_7_12 Texture Mapping to a Shape
Texture mapping allows you to map textures on a shape. Textures are texture image files and several are predefined. You can control the number of occurrences of the texture on a face, the position of a texture and the scale factor of the texture.

BIN
dox/user_guides/modeling_algos/images/modeling_algos_image062.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 6.0 KiB

BIN
dox/user_guides/modeling_algos/images/modeling_algos_image063.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 5.4 KiB

BIN
dox/user_guides/modeling_algos/images/modeling_algos_image064.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 2.1 KiB

BIN
dox/user_guides/modeling_algos/images/modeling_algos_image065.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 2.2 KiB

114
dox/user_guides/modeling_algos/modeling_algos.md
View File

@ -1066,6 +1066,120 @@ Handle(Geom2d_Curve) C2d = GeomAPI::To2d(C3d, Pln);
Handle(Geom_Curve) C3d = GeomAPI::To3d(C2d, Pln);
~~~~~
@section occt_modalg_2_topo_tools Topological Tools
Open CASCADE Technology topological tools provide algorithms to
* Create wires from edges;
* Create faces from wires;
* Compute state of the shape relatively other shape;
* Orient shapes in container;
* Create new shapes from the existing ones;
* Build PCurves of edges on the faces;
* Check the validity of the shapes;
* Take the point in the face;
* Get the normal direction for the face.
@subsection occt_modalg_2_topo_tools_1 Creation of the faces from wireframe model
It is possible to create the planar faces from the arbitrary set of planar edges randomly located in 3D space.
This feature might be useful if you need for instance to restore the shape from the wireframe model:
<table align="center">
<tr>
<td>@figure{/user_guides/modeling_algos/images/modeling_algos_image062.png, "Wireframe model"}</td>
<td>@figure{/user_guides/modeling_algos/images/modeling_algos_image063.png, "Faces of the model"}</td>
</tr>
</table>
To make the faces from edges it is, firstly, necessary to create planar wires from the given edges and than create planar faces from each wire.
The static methods *BOPAlgo_Tools::EdgesToWires* and *BOPAlgo_Tools::WiresToFaces* can be used for that:
~~~~~
TopoDS_Shape anEdges = ...; /* The input edges */
Standard_Real anAngTol = 1.e-8; /* The angular tolerance for distinguishing the planes in which the wires are located */
Standard_Boolean bShared = Standard_False; /* Defines whether the edges are shared or not */
//
TopoDS_Shape aWires; /* resulting wires */
Standard_Integer iErr = BOPAlgo_Tools::EdgesToWires(anEdges, aWires, bShared, anAngTol);
if (iErr) {
cout << "Error: Unable to build wires from given edges\n";
return;
}
//
TopoDS_Shape aFaces; /* resulting faces */
Standard_Boolean bDone = BOPAlgo_Tools::WiresToFaces(aWires, aFaces, anAngTol);
if (!bDone) {
cout << "Error: Unable to build faces from wires\n";
return;
}
~~~~~
These methods can also be used separately:
* *BOPAlgo_Tools::EdgesToWires* allows creating planar wires from edges.
The input edges may be not shared, but the output wires will be sharing the coinciding vertices and edges. For this the intersection of the edges is performed.
Although, it is possible to skip the intersection stage (if the input edges are already shared) by passing the corresponding flag into the method.
The input edges are expected to be planar, but the method does not check it. Thus, if the input edges are not planar, the output wires will also be not planar.
In general, the output wires are non-manifold and may contain free vertices, as well as multi-connected vertices.
* *BOPAlgo_Tools::WiresToFaces* allows creating planar faces from the planar wires.
In general, the input wires are non-manifold and may be not closed, but should share the coinciding parts.
The wires located in the same plane and completely included into other wires will create holes in the faces built from outer wires:
<table align="center">
<tr>
<td>@figure{/user_guides/modeling_algos/images/modeling_algos_image064.png, "Wireframe model"}</td>
<td>@figure{/user_guides/modeling_algos/images/modeling_algos_image065.png, "Two faces (red face has a hole)"}</td>
</tr>
</table>
@subsection occt_modalg_2_topo_tools_2 Classification of the shapes
The following methods allow classifying the different shapes relatively other shapes:
* The variety of the *BOPTools_AlgoTools::ComputState* methods classify the vertex/edge/face relatively solid;
* *BOPTools_AlgoTools::IsHole* classifies wire relatively face;
* *IntTools_Tools::ClassifyPointByFace* classifies point relatively face.
@subsection occt_modalg_2_topo_tools_3 Orientation of the shapes in the container
The following methods allow reorienting shapes in the containers:
* *BOPTools_AlgoTools::OrientEdgesOnWire* correctly orients edges on the wire;
* *BOPTools_AlgoTools::OrientFacesOnShell* correctly orients faces on the shell.
@subsection occt_modalg_2_topo_tools_4 Making new shapes
The following methods allow creating new shapes from the existing ones:
* The variety of the *BOPTools_AlgoTools::MakeNewVertex* creates the new vertices from other vertices and edges;
* *BOPTools_AlgoTools::MakeSplitEdge* splits the edge by the given parameters.
@subsection occt_modalg_2_topo_tools_5 Building PCurves
The following methods allow building PCurves of edges on faces:
* *BOPTools_AlgoTools::BuildPCurveForEdgeOnFace* computes PCurve for the edge on the face;
* *BOPTools_AlgoTools::BuildPCurveForEdgeOnPlane* and *BOPTools_AlgoTools::BuildPCurveForEdgesOnPlane* allow building PCurves for edges on the planar face;
* *BOPTools_AlgoTools::AttachExistingPCurve* takes PCurve on the face from one edge and attach this PCurve to other edge coinciding with the first one.
@subsection occt_modalg_2_topo_tools_6 Checking the validity of the shapes
The following methods allow checking the validity of the shapes:
* *BOPTools_AlgoTools::IsMicroEdge* detects the small edges;
* *BOPTools_AlgoTools::ComputeTolerance* computs the correct tolerance for the edge on the face;
* *BOPTools_AlgoTools::CorrectShapeTolerances* and *BOPTools_AlgoTools::CorrectTolerances* allows correcting the tolerances of the sub-shapes.
@subsection occt_modalg_2_topo_tools_7 Taking a point inside the face
The following methods allow taking a point located inside the face:
* The variety of the *BOPTools_AlgoTools3D::PointNearEdge* allows getting a point inside the face located near the edge;
* *BOPTools_AlgoTools3D::PointInFace* allows getting a point inside the face.
@subsection occt_modalg_2_topo_tools_8 Getting normal for the face
The following methods allow getting the normal direction for the face/surface:
* *BOPTools_AlgoTools3D::GetNormalToSurface* computes the normal direction for the surface in the given point defined by UV parameters;
* *BOPTools_AlgoTools3D::GetNormalToFaceOnEdge* computes the normal direction for the face in the point located on the edge of the face;
* *BOPTools_AlgoTools3D::GetApproxNormalToFaceOnEdge* computes the normal direction for the face in the point located near the edge of the face.
@section occt_modalg_3a The Topology API
The Topology API of Open CASCADE Technology (**OCCT**) includes the following six packages:

695
src/BOPAlgo/BOPAlgo_Tools.cxx
View File

@ -14,17 +14,85 @@
#include <BOPAlgo_Tools.hxx>
#include <gp_Pnt.hxx>
#include <gp_Vec.hxx>
#include <gp_Dir.hxx>
#include <gp_Pln.hxx>
#include <gp_Circ.hxx>
#include <gp_Elips.hxx>
#include <gp_Hypr.hxx>
#include <gp_Parab.hxx>
#include <Standard_ErrorHandler.hxx>
#include <Standard_Failure.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Edge.hxx>
#include <BOPCol_MapOfShape.hxx>
#include <BOPCol_IndexedMapOfShape.hxx>
#include <BOPCol_IndexedMapOfInteger.hxx>
#include <BOPCol_IndexedDataMapOfShapeListOfShape.hxx>
#include <TopExp_Explorer.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BRepBuilderAPI_MakeFace.hxx>
#include <BRep_Tool.hxx>
#include <BRep_Builder.hxx>
#include <GeomAPI_ProjectPointOnCurve.hxx>
#include <GeomAPI_ProjectPointOnSurf.hxx>
#include <BOPAlgo_Builder.hxx>
#include <BOPAlgo_BuilderFace.hxx>
#include <BOPDS_CommonBlock.hxx>
#include <BOPDS_DataMapOfPaveBlockListOfPaveBlock.hxx>
#include <BOPDS_DS.hxx>
#include <BOPDS_IndexedMapOfPaveBlock.hxx>
#include <BOPDS_MapOfPaveBlock.hxx>
#include <BOPDS_PaveBlock.hxx>
#include <BOPTools.hxx>
#include <BOPTools_AlgoTools.hxx>
#include <BOPTools_AlgoTools2D.hxx>
#include <IntTools_Context.hxx>
#include <BRep_Tool.hxx>
#include <GeomAPI_ProjectPointOnCurve.hxx>
#include <GeomAPI_ProjectPointOnSurf.hxx>
typedef NCollection_IndexedDataMap
<TopoDS_Shape, gp_Dir, TopTools_ShapeMapHasher> BOPAlgo_IndexedDataMapOfShapeDir;
typedef NCollection_IndexedDataMap
<TopoDS_Shape, gp_Pln, TopTools_ShapeMapHasher> BOPAlgo_IndexedDataMapOfShapePln;
static
void MakeWires(const BOPCol_IndexedMapOfShape& theEdges,
TopoDS_Compound& theWires,
const Standard_Boolean theCheckUniquePlane,
BOPAlgo_IndexedDataMapOfShapeDir& theDMEdgeTgt,
BOPCol_MapOfShape& theMEdgesNoUniquePlane);
static
Standard_Boolean FindPlane(const BRepAdaptor_Curve& theCurve,
gp_Pln& thePlane);
static
Standard_Boolean FindPlane(const TopoDS_Shape& theWire,
gp_Pln& thePlane,
BOPAlgo_IndexedDataMapOfShapeDir& theDMEdgeTgt,
BOPCol_MapOfShape& theMEdgesNoUniquePlane);
static
Standard_Boolean FindEdgeTangent(const TopoDS_Edge& theEdge,
BOPAlgo_IndexedDataMapOfShapeDir& theDMEdgeTgt,
gp_Dir& theTgt);
static
Standard_Boolean FindEdgeTangent(const BRepAdaptor_Curve& theCurve,
gp_Vec& theTangent);
//=======================================================================
//function : MakeBlocksCnx
@ -451,3 +519,624 @@ Standard_Real BOPAlgo_Tools::ComputeToleranceOfCB
//
return aTolMax;
}
//=======================================================================
//function : EdgesToWires
//purpose :
//=======================================================================
Standard_Integer BOPAlgo_Tools::EdgesToWires(const TopoDS_Shape& theEdges,
TopoDS_Shape& theWires,
const Standard_Boolean theShared,
const Standard_Real theAngTol)
{
Standard_Integer iErr = 0;
//
// 1. Check the input edges
//
// List of edges to process
BOPCol_ListOfShape aLE;
//
TopExp_Explorer aExp(theEdges, TopAbs_EDGE);
for (; aExp.More(); aExp.Next()) {
const TopoDS_Edge& aE = TopoDS::Edge(aExp.Current());
if (!BRep_Tool::Degenerated(aE) && BRep_Tool::IsGeometric(aE)) {
aLE.Append(aExp.Current());
}
}
//
if (aLE.IsEmpty()) {
// no edges to process
iErr = 1;
return iErr;
}
//
BRep_Builder aBB;
TopoDS_Compound aRWires;
aBB.MakeCompound(aRWires);
//
if (aLE.Extent() == 1) {
TopoDS_Wire aWire;
aBB.MakeWire(aWire);
aBB.Add(aWire, aLE.First());
aBB.Add(aRWires, aWire);
theWires = aRWires;
return iErr;
}
//
// 2. Make compound of shared edges
TopoDS_Shape aSEdges;
//
if (!theShared) {
// intersect the edges if necessary
BOPAlgo_Builder aGF;
aGF.SetArguments(aLE);
aGF.Perform();
if (aGF.ErrorStatus()) {
// unable to share the edges
iErr = 2;
return iErr;
}
//
aSEdges = aGF.Shape();
}
else {
aBB.MakeCompound(TopoDS::Compound(aSEdges));
BOPCol_ListIteratorOfListOfShape aItLE(aLE);
for (; aItLE.More(); aItLE.Next()) {
aBB.Add(aSEdges, aItLE.Value());
}
}
//
// 3. Find edges located in the same planes and make wires from them.
// If the plane cannot be found for a single edge, then it is necessary
// to find all pairs of connected edges with the same cross product.
// Try to compute the plane in which the edge is located
BOPAlgo_IndexedDataMapOfShapePln aDMEdgePln;
// Compute the tangent direction for the edges for which the plane is not defined
BOPAlgo_IndexedDataMapOfShapeDir aDMEdgeTgt;
//
// edges for which the plane is not found
BOPCol_MapOfShape aMEdgesNoUniquePlane;
//
// edges for which the plane cannot be found on a single edge
TopoDS_Compound aLEdges;
aBB.MakeCompound(aLEdges);
//
aExp.Init(aSEdges, TopAbs_EDGE);
for (; aExp.More(); aExp.Next()) {
const TopoDS_Edge& aE = TopoDS::Edge(aExp.Current());
BRepAdaptor_Curve aBAC(aE);
//
gp_Pln aPln;
if (FindPlane(aBAC, aPln)) {
aDMEdgePln.Add(aE, aPln);
}
else {
gp_Vec aVT;
if (FindEdgeTangent(aBAC, aVT)) {
aDMEdgeTgt.Add(aE, gp_Dir(aVT));
aBB.Add(aLEdges, aE);
aMEdgesNoUniquePlane.Add(aE);
}
}
}
//
typedef NCollection_List<gp_Dir> BOPAlgo_ListOfDir;
//
// to avoid processing of the same edges in the same plane store
// the processed planes into a list and use it as a fence map
BOPAlgo_ListOfDir aLPFence;
//
// used edges
BOPCol_MapOfShape aMEFence;
//
// look for a planes on the single edges
Standard_Integer i, j, aNbPlanes = aDMEdgePln.Extent(), aNbEdges = aDMEdgeTgt.Extent();
for (i = 1; i <= aNbPlanes; ++i) {
const TopoDS_Shape& aEI = aDMEdgePln.FindKey(i);
if (!aMEFence.Add(aEI)) {
continue;
}
//
const gp_Pln& aPlnI = aDMEdgePln(i);
const gp_Dir& aDI = aPlnI.Position().Direction();
//
aLPFence.Append(aDI);
//
BOPCol_IndexedMapOfShape aMEPln;
aMEPln.Add(aEI);
//
BOPCol_IndexedMapOfShape aMV;
BOPTools::MapShapes(aEI, TopAbs_VERTEX, aMV);
//
// look for other edges with the plane parallel to current one
for (j = i + 1; j <= aNbPlanes; ++j) {
const gp_Dir& aDJ = aDMEdgePln(j).Position().Direction();
if (aDI.IsParallel(aDJ, theAngTol)) {
const TopoDS_Shape& aEJ = aDMEdgePln.FindKey(j);
aMEPln.Add(aEJ);
aMEFence.Add(aEJ);
BOPTools::MapShapes(aEJ, TopAbs_VERTEX, aMV);
}
}
//
// look for all other edges located in the plane parallel to current one
TopoDS_Compound aCEPln;
aBB.MakeCompound(aCEPln);
//
for (j = 1; j <= aNbEdges; ++j) {
const gp_Dir& aDJ = aDMEdgeTgt(j);
if (aDI.IsNormal(aDJ, theAngTol)) {
aBB.Add(aCEPln, aDMEdgeTgt.FindKey(j));
}
}
//
// make blocks of these edges and check blocks to be connected
// to any of the already added edges or forming a wire themselves
BOPCol_ListOfShape aLCBE;
BOPTools_AlgoTools::MakeConnexityBlocks(aCEPln, TopAbs_VERTEX, TopAbs_EDGE, aLCBE);
//
// make wire from each block
BOPCol_ListIteratorOfListOfShape aItLCB(aLCBE);
for (; aItLCB.More(); aItLCB.Next()) {
const TopoDS_Shape& aCBE = aItLCB.Value();
//
// check connectivity
TopExp_Explorer aExpV(aCBE, TopAbs_VERTEX);
for (; aExpV.More(); aExpV.Next()) {
if (aMV.Contains(aExpV.Current())) {
break;
}
}
//
Standard_Boolean bAddBlock = aExpV.More();
if (!bAddBlock) {
// check if the edges are forming a wire
gp_Pln aPln;
bAddBlock = FindPlane(aCBE, aPln, aDMEdgeTgt, aMEdgesNoUniquePlane);
}
//
if (bAddBlock) {
// add edges
for (TopoDS_Iterator aItE(aCBE); aItE.More(); aItE.Next()) {
aMEPln.Add(aItE.Value());
}
}
}
//
MakeWires(aMEPln, aRWires, Standard_False, aDMEdgeTgt, aMEdgesNoUniquePlane);
}
//
// make connection map from vertices to edges to find the connected pairs
BOPCol_IndexedDataMapOfShapeListOfShape aDMVE;
BOPTools::MapShapesAndAncestors(aLEdges, TopAbs_VERTEX, TopAbs_EDGE, aDMVE);
//
// find planes for connected edges
Standard_Integer aNbV = aDMVE.Extent();
for (i = 1; i <= aNbV; ++i) {
const BOPCol_ListOfShape& aLEI = aDMVE(i);
if (aLEI.Extent() < 2) {
continue;
}
//
BOPCol_ListIteratorOfListOfShape aItLEI1(aLEI);
for (; aItLEI1.More(); aItLEI1.Next()) {
const TopoDS_Shape& aEI1 = aItLEI1.Value();
const gp_Dir& aDI1 = aDMEdgeTgt.FindFromKey(aEI1);
//
BOPCol_ListIteratorOfListOfShape aItLEI2(aLEI);
for (; aItLEI2.More(); aItLEI2.Next()) {
const TopoDS_Shape& aEI2 = aItLEI2.Value();
if (aEI2.IsSame(aEI1)) {
continue;
}
//
const gp_Dir& aDI2 = aDMEdgeTgt.FindFromKey(aEI2);
//
if (aDI1.IsParallel(aDI2, theAngTol)) {
continue;
}
//
gp_Dir aDNI = aDI1^aDI2;
//
// check if this normal direction has not been checked yet
BOPAlgo_ListOfDir::Iterator aItLPln(aLPFence);
for (; aItLPln.More(); aItLPln.Next()) {
if (aDNI.IsParallel(aItLPln.Value(), theAngTol)) {
break;
}
}
if (aItLPln.More()) {
continue;
}
//
aLPFence.Append(aDNI);
//
// find all other edges in the plane parallel to current one
BOPCol_IndexedMapOfShape aMEPln;
aMEPln.Add(aEI1);
aMEPln.Add(aEI2);
//
// iterate on all other edges to find all edges lying in the plane parallel to current one
for (j = 1; j <= aNbEdges; ++j) {
const gp_Dir& aDJ = aDMEdgeTgt(j);
if (aDNI.IsNormal(aDJ, theAngTol)) {
aMEPln.Add(aDMEdgeTgt.FindKey(j));
}
}
//
MakeWires(aMEPln, aRWires, Standard_True, aDMEdgeTgt, aMEdgesNoUniquePlane);
} // for (; aItLEI2.More(); aItLEI2.Next()) {
} // for (; aItLEI1.More(); aItLEI1.Next()) {
} // for (i = 1; i < aNb; ++i) {
//
// 4. Find unused edges and make wires from them
BOPCol_IndexedMapOfShape aMEAlone, aMEUsed;
BOPTools::MapShapes(aRWires, TopAbs_EDGE, aMEUsed);
//
for (i = 1; i <= aNbEdges; ++i) {
const TopoDS_Shape& aE = aDMEdgeTgt.FindKey(i);
if (!aMEUsed.Contains(aE)) {
aMEAlone.Add(aE);
}
}
//
MakeWires(aMEAlone, aRWires, Standard_False, aDMEdgeTgt, aMEdgesNoUniquePlane);
//
theWires = aRWires;
//
return iErr;
}
//=======================================================================
//function : WiresToFaces
//purpose :
//=======================================================================
Standard_Boolean BOPAlgo_Tools::WiresToFaces(const TopoDS_Shape& theWires,
TopoDS_Shape& theFaces,
const Standard_Real theAngTol)
{
BRep_Builder aBB;
BOPCol_MapOfShape aMFence;
TopoDS_Compound aRFaces;
aBB.MakeCompound(aRFaces);
//
const Standard_Real aMax = 1.e+8;
//
// map to store the tangent vectors for the edges
BOPAlgo_IndexedDataMapOfShapeDir aDMEdgeTgt;
// maps to store the planes found for the wires
BOPAlgo_IndexedDataMapOfShapePln aDMWirePln;
// map to store the tolerance for the wire
NCollection_DataMap<TopoDS_Shape, Standard_Real, TopTools_ShapeMapHasher> aDMWireTol;
// edges for which the plane is not found
BOPCol_MapOfShape aMEdgesNoUniquePlane;
//
// Find planes for the wires
TopExp_Explorer aExpW(theWires, TopAbs_WIRE);
for (; aExpW.More(); aExpW.Next()) {
const TopoDS_Wire& aWire = TopoDS::Wire(aExpW.Current());
gp_Pln aPlane;
if (FindPlane(aWire, aPlane, aDMEdgeTgt, aMEdgesNoUniquePlane)) {
aDMWirePln.Add(aWire, aPlane);
// find tolerance for the wire - max tolerance of its edges
aDMWireTol.Bind(aWire, BRep_Tool::MaxTolerance(aWire, TopAbs_EDGE));
}
}
//
Standard_Integer i, j, aNb = aDMWirePln.Extent();
for (i = 1; i <= aNb; ++i) {
const TopoDS_Shape& aWireI = aDMWirePln.FindKey(i);
if (aMFence.Contains(aWireI)) {
continue;
}
//
const gp_Pln& aPlnI = aDMWirePln(i);
//
BOPCol_ListOfShape aLW;
aLW.Append(aWireI);
aMFence.Add(aWireI);
//
Standard_Real aTolI = aDMWireTol.Find(aWireI);
//
// Find other wires in the same plane
for (j = i + 1; j <= aNb; ++j) {
const TopoDS_Shape& aWireJ = aDMWirePln.FindKey(j);
if (aMFence.Contains(aWireJ)) {
continue;
}
//
// check if the planes are the same
const gp_Pln& aPlnJ = aDMWirePln(j);
// check direction of the planes
if (!aPlnI.Position().Direction().IsParallel(aPlnJ.Position().Direction(), theAngTol)) {
continue;
}
// check distance between the planes
Standard_Real aDist = aPlnI.Distance(aPlnJ.Location());
Standard_Real aTolJ = aDMWireTol.Find(aWireJ);
if (aDist > (aTolI + aTolJ)) {
continue;
}
//
aLW.Append(aWireJ);
aMFence.Add(aWireJ);
}
//
// Take the edges to build the face
BOPCol_ListOfShape aLE;
BOPCol_ListIteratorOfListOfShape aItLW(aLW);
for (; aItLW.More(); aItLW.Next()) {
TopoDS_Iterator aItE(aItLW.Value());
for (; aItE.More(); aItE.Next()) {
aLE.Append(aItE.Value().Oriented(TopAbs_FORWARD));
aLE.Append(aItE.Value().Oriented(TopAbs_REVERSED));
}
}
//
// build planar face
TopoDS_Face aFF = BRepBuilderAPI_MakeFace
(aPlnI, -aMax, aMax, -aMax, aMax).Face();
aFF.Orientation(TopAbs_FORWARD);
//
try {
OCC_CATCH_SIGNALS
//
// build pcurves for edges on this face
BOPTools_AlgoTools2D::BuildPCurveForEdgesOnPlane(aLE, aFF);
//
// split the face with the edges
BOPAlgo_BuilderFace aBF;
aBF.SetShapes(aLE);
aBF.SetFace(aFF);
aBF.Perform();
if (aBF.ErrorStatus()) {
continue;
}
//
const BOPCol_ListOfShape& aLFSp = aBF.Areas();
BOPCol_ListIteratorOfListOfShape aItLF(aLFSp);
for (; aItLF.More(); aItLF.Next()) {
const TopoDS_Shape& aFSp = aItLF.ChangeValue();
aBB.Add(aRFaces, aFSp);
}
}
catch (Standard_Failure) {
continue;
}
}
//
// fix tolerances of the resulting faces
BOPCol_IndexedMapOfShape aMEmpty;
BOPTools_AlgoTools::CorrectTolerances(aRFaces, aMEmpty, 0.05, Standard_False);
BOPTools_AlgoTools::CorrectShapeTolerances(aRFaces, aMEmpty, Standard_False);
//
theFaces = aRFaces;
TopoDS_Iterator aItF(theFaces);
return aItF.More();
}
//=======================================================================
//function : MakeWires
//purpose : Makes wires from the separate blocks of the given edges
//=======================================================================
void MakeWires(const BOPCol_IndexedMapOfShape& theEdges,
TopoDS_Compound& theWires,
const Standard_Boolean theCheckUniquePlane,
BOPAlgo_IndexedDataMapOfShapeDir& theDMEdgeTgt,
BOPCol_MapOfShape& theMEdgesNoUniquePlane)
{
TopoDS_Compound aCE;
BRep_Builder().MakeCompound(aCE);
Standard_Integer i, aNbE = theEdges.Extent();
for (i = 1; i <= aNbE; ++i) {
BRep_Builder().Add(aCE, theEdges(i));
}
//
BOPCol_ListOfShape aLCBE;
BOPTools_AlgoTools::MakeConnexityBlocks(aCE, TopAbs_VERTEX, TopAbs_EDGE, aLCBE);
//
// make wire from each block
BOPCol_ListIteratorOfListOfShape aItLCB(aLCBE);
for (; aItLCB.More(); aItLCB.Next()) {
const TopoDS_Shape& aCBE = aItLCB.Value();
//
if (theCheckUniquePlane) {
gp_Pln aPln;
if (!FindPlane(aCBE, aPln, theDMEdgeTgt, theMEdgesNoUniquePlane)) {
continue;
}
}
//
TopoDS_Wire aWire;
BRep_Builder().MakeWire(aWire);
for (TopoDS_Iterator aItE(aCBE); aItE.More(); aItE.Next()) {
BRep_Builder().Add(aWire, aItE.Value());
}
//
BRep_Builder().Add(theWires, aWire);
}
}
//=======================================================================
//function : FindEdgeTangent
//purpose : Finds the tangent for the edge using the map
//=======================================================================
Standard_Boolean FindEdgeTangent(const TopoDS_Edge& theEdge,
BOPAlgo_IndexedDataMapOfShapeDir& theDMEdgeTgt,
gp_Dir& theTgt)
{
gp_Dir *pDTE = theDMEdgeTgt.ChangeSeek(theEdge);
if (!pDTE) {
gp_Vec aVTE;
BRepAdaptor_Curve aBAC(theEdge);
if (!FindEdgeTangent(aBAC, aVTE)) {
return Standard_False;
}
pDTE = &theDMEdgeTgt(theDMEdgeTgt.Add(theEdge, gp_Dir(aVTE)));
}
theTgt = *pDTE;
return Standard_True;
}
//=======================================================================
//function : FindEdgeTangent
//purpose : Finds the tangent for the edge
//=======================================================================
Standard_Boolean FindEdgeTangent(const BRepAdaptor_Curve& theCurve,
gp_Vec& theTangent)
{
if (!theCurve.Is3DCurve()) {
return Standard_False;
}
// for the line the tangent is defined by the direction
if (theCurve.GetType() == GeomAbs_Line) {
theTangent = theCurve.Line().Position().Direction();
return Standard_True;
}
//
// for other curves take D1 and check for its length
Standard_Real aT, aT1(theCurve.FirstParameter()), aT2(theCurve.LastParameter());
const Standard_Integer aNbP = 11;
const Standard_Real aDt = (aT2 - aT1) / aNbP;
//
for (aT = aT1 + aDt; aT <= aT2; aT += aDt) {
gp_Pnt aP;
theCurve.D1(aT, aP, theTangent);
if (theTangent.Magnitude() > Precision::Confusion()) {
return Standard_True;
}
}
//
return Standard_False;
}
//=======================================================================
//function : FindPlane
//purpose : Finds the plane in which the edge is located
//=======================================================================
Standard_Boolean FindPlane(const BRepAdaptor_Curve& theCurve,
gp_Pln& thePlane)
{
if (!theCurve.Is3DCurve()) {
return Standard_False;
}
//
Standard_Boolean bFound = Standard_True;
gp_Vec aVN;
switch (theCurve.GetType()) {
case GeomAbs_Line:
return Standard_False;
case GeomAbs_Circle:
aVN = theCurve.Circle().Position().Direction();
break;
case GeomAbs_Ellipse:
aVN = theCurve.Ellipse().Position().Direction();
break;
case GeomAbs_Hyperbola:
aVN = theCurve.Hyperbola().Position().Direction();
break;
case GeomAbs_Parabola:
aVN = theCurve.Parabola().Position().Direction();
break;
default: {
// for all other types of curve compute two tangent vectors
// on the curve and cross them
bFound = Standard_False;
Standard_Real aT, aT1(theCurve.FirstParameter()), aT2(theCurve.LastParameter());
const Standard_Integer aNbP = 11;
const Standard_Real aDt = (aT2 - aT1) / aNbP;
//
aT = aT1;
gp_Pnt aP1;
gp_Vec aV1;
theCurve.D1(aT, aP1, aV1);
//
for (aT = aT1 + aDt; aT <= aT2; aT += aDt) {
gp_Pnt aP2;
gp_Vec aV2;
theCurve.D1(aT, aP2, aV2);
//
aVN = aV1^aV2;
if (aVN.Magnitude() > Precision::Confusion()) {
bFound = Standard_True;
break;
}
}
break;
}
}
//
if (bFound) {
thePlane = gp_Pln(theCurve.Value(theCurve.FirstParameter()), gp_Dir(aVN));
}
return bFound;
}
//=======================================================================
//function : FindPlane
//purpose : Finds the plane in which the wire is located
//=======================================================================
Standard_Boolean FindPlane(const TopoDS_Shape& theWire,
gp_Pln& thePlane,
BOPAlgo_IndexedDataMapOfShapeDir& theDMEdgeTgt,
BOPCol_MapOfShape& theMEdgesNoUniquePlane)
{
TopExp_Explorer aExpE1(theWire, TopAbs_EDGE);
if (!aExpE1.More()) {
return Standard_False;
}
//
// try to find two not parallel edges in wire to get normal of the plane
for (; aExpE1.More(); aExpE1.Next()) {
// get the first edge in the wire
const TopoDS_Edge& aE1 = TopoDS::Edge(aExpE1.Current());
//
// find tangent for the first edge
gp_Dir aDTE1;
if (!FindEdgeTangent(aE1, theDMEdgeTgt, aDTE1)) {
continue;
}
//
// find the other edge not parallel to the first one
TopExp_Explorer aExpE2(theWire, TopAbs_EDGE);
for (; aExpE2.More(); aExpE2.Next()) {
const TopoDS_Edge& aE2 = TopoDS::Edge(aExpE2.Current());
if (aE1.IsSame(aE2)) {
continue;
}
//
// find tangent for the second edge
gp_Dir aDTE2;
if (!FindEdgeTangent(aE2, theDMEdgeTgt, aDTE2)) {
continue;
}
//
if (aDTE1.IsParallel(aDTE2, Precision::Angular())) {
continue;
}
//
gp_Dir aDN = aDTE1^aDTE2;
//
TopoDS_Iterator aItV(aE1);
thePlane = gp_Pln(BRep_Tool::Pnt(TopoDS::Vertex(aItV.Value())), aDN);
return Standard_True;
}
}
//
// try to compute normal on the single edge
aExpE1.Init(theWire, TopAbs_EDGE);
for (; aExpE1.More(); aExpE1.Next()) {
const TopoDS_Edge& aE = TopoDS::Edge(aExpE1.Current());
if (theMEdgesNoUniquePlane.Contains(aE)) {
continue;
}
BRepAdaptor_Curve aBAC(aE);
if (FindPlane(aBAC, thePlane)) {
return Standard_True;
}
theMEdgesNoUniquePlane.Add(aE);
}
return Standard_False;
}

42
src/BOPAlgo/BOPAlgo_Tools.hxx
View File

@ -31,6 +31,7 @@
class BOPDS_PaveBlock;
class BOPDS_CommonBlock;
class IntTools_Context;
class TopoDS_Shape;
class BOPAlgo_Tools
{
@ -58,6 +59,47 @@ public:
const BOPDS_PDS theDS,
const Handle(IntTools_Context)& theContext);
//! Creates planar wires from the given edges.<br>
//! The input edges are expected to be planar. And for the performance
//! sake the method does not check if the edges are really planar.<br>
//! Thus, the result wires will also be not planar if the input edges are not planar.<br>
//! The edges may be not shared, but the resulting wires will be sharing the
//! coinciding parts and intersecting parts.<br>
//! The output wires may be non-manifold and contain free and multi-connected vertices.<br>
//! Parameters:
//! <theEdges> - input edges;<br>
//! <theWires> - output wires;<br>
//! <theShared> - boolean flag which defines whether the input edges are already
//! shared or have to be intersected;<br>
//! <theAngTol> - the angular tolerance which will be used for distinguishing
//! the planes in which the edges are located. Default value is
//! 1.e-8 which is used for intersection of planes in IntTools_FaceFace.<br>
//! Method returns the following error statuses:<br>
//! 0 - in case of success (at least one wire has been built);<br>
//! 1 - in case there are no edges in the given shape;<br>
//! 2 - sharing of the edges has failed.<br>
Standard_EXPORT static Standard_Integer EdgesToWires(const TopoDS_Shape& theEdges,
TopoDS_Shape& theWires,
const Standard_Boolean theShared = Standard_False,
const Standard_Real theAngTol = 1.e-8);
//! Creates planar faces from given planar wires.<br>
//! The method does not check if the wires are really planar.<br>
//! The input wires may be non-manifold but should be shared.<br>
//! The wires located in the same planes and included into other wires will create
//! holes in the faces built from outer wires.<br>
//! The tolerance values of the input shapes may be modified during the operation
//! due to projection of the edges on the planes for creation of 2D curves.<br>
//! Parameters:
//! <theWires> - the given wires;<br>
//! <theFaces> - the output faces;<br>
//! <theAngTol> - the angular tolerance for distinguishing the planes in which
//! the wires are located. Default value is 1.e-8 which is used
//! for intersection of planes in IntTools_FaceFace.<br>
//! Method returns TRUE in case of success, i.e. at least one face has been built.<br>
Standard_EXPORT static Standard_Boolean WiresToFaces(const TopoDS_Shape& theWires,
TopoDS_Shape& theFaces,
const Standard_Real theAngTol = 1.e-8);
};
#endif // _BOPAlgo_Tools_HeaderFile

57
src/BOPTest/BOPTest_UtilityCommands.cxx
View File

@ -23,10 +23,12 @@
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Shape.hxx>
#include <Draw.hxx>
#include <BOPAlgo_Tools.hxx>
static Standard_Integer attachpcurve (Draw_Interpretor&, Standard_Integer, const char**);
static Standard_Integer edgestowire (Draw_Interpretor&, Standard_Integer, const char**);
static Standard_Integer edgestofaces (Draw_Interpretor&, Standard_Integer, const char**);
//=======================================================================
//function : BOPCommands
@ -43,6 +45,7 @@ static Standard_Integer edgestowire (Draw_Interpretor&, Standard_Integer, const
theCommands.Add("attachpcurve", "attachpcurve eold enew face", __FILE__, attachpcurve, group);
theCommands.Add("edgestowire" , "edgestowire wire edges" , __FILE__, edgestowire , group);
theCommands.Add("edgestofaces" , "edgestofaces faces edges [-a AngTol -s Shared(0/1)]", __FILE__, edgestofaces , group);
}
//=======================================================================
@ -128,3 +131,55 @@ static Standard_Integer edgestowire(Draw_Interpretor& theDI,
DBRep::Set(theArgVal[1], anEdges);
return 0;
}
//=======================================================================
//function : edgestofaces
//purpose : Creates planar faces from linear edges
//=======================================================================
static Standard_Integer edgestofaces(Draw_Interpretor& theDI,
Standard_Integer theNArg,
const char ** theArgVal)
{
if (theNArg < 3) {
theDI << "Use: edgestofaces faces edges [-a AngTol -s Shared(0/1)]\n";
theDI << " AngTol - angular tolerance for comparing the planes;\n";
theDI << " Shared - boolean flag which defines whether the input\n";
theDI << " edges are already shared or have to be intersected.\n";
return 1;
}
//
TopoDS_Shape anEdges = DBRep::Get(theArgVal[2]);
if (anEdges.IsNull()) {
theDI << "no edges\n";
return 1;
}
//
Standard_Real anAngTol = 1.e-8;
Standard_Boolean bShared = Standard_False;
//
for (Standard_Integer i = 3; i < theNArg; ++i) {
if (!strcmp(theArgVal[i], "-a") && (i+1 < theNArg)) {
anAngTol = Draw::Atof(theArgVal[i+1]);
}
if (!strcmp(theArgVal[i], "-s") && (i+1 < theNArg)) {
bShared = (Draw::Atoi(theArgVal[i+1]) == 1);
}
}
//
TopoDS_Shape aWires;
Standard_Integer iErr = BOPAlgo_Tools::EdgesToWires(anEdges, aWires, bShared, anAngTol);
if (iErr) {
theDI << "Unable to build wires from given edges\n";
return 0;
}
//
TopoDS_Shape aFaces;
Standard_Boolean bDone = BOPAlgo_Tools::WiresToFaces(aWires, aFaces, anAngTol);
if (!bDone) {
theDI << "Unable to build faces from wires\n";
return 0;
}
//
DBRep::Set(theArgVal[1], aFaces);
return 0;
}

19
tests/mkface/edges_to_faces/A1 Normal file
View File

@ -0,0 +1,19 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
box b1 10 10 10
eval compound [explode b1 e] c
edgestofaces result c
checkshape result
checknbshapes result -face 6 -wire 6
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}

20
tests/mkface/edges_to_faces/A2 Normal file
View File

@ -0,0 +1,20 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
box b1 10 10 10
box b2 10 0 0 10 10 10
eval compound [explode b1 e] [explode b2 e] c
edgestofaces result c
checkshape result
checknbshapes result -face 11 -wire 11
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}

20
tests/mkface/edges_to_faces/A3 Normal file
View File

@ -0,0 +1,20 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
box b1 10 10 10
box b2 10 5 5 10 10 10
eval compound [explode b1 e] [explode b2 e] c
edgestofaces result c
checkshape result
checknbshapes result -face 13 -wire 13
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}

20
tests/mkface/edges_to_faces/A4 Normal file
View File

@ -0,0 +1,20 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
box b1 10 10 10
box b2 10 0 0 10 10 5
eval compound [explode b1 e] [explode b2 e] c
edgestofaces result c
checkshape result
checknbshapes result -face 12 -wire 12
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}

20
tests/mkface/edges_to_faces/A5 Normal file
View File

@ -0,0 +1,20 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
box b1 10 10 10
box b2 2 2 10 6 6 6
eval compound [explode b1 e] [explode b2 e] c
edgestofaces result c
checkshape result
checknbshapes result -face 12 -wire 13
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}

21
tests/mkface/edges_to_faces/A6 Normal file
View File

@ -0,0 +1,21 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
restore [locate_data_file bug26917_input_dom6820_1.brep] s
eval compound [explode s e] c
edgestofaces result c
checkshape result
checknbshapes result -face 618 -wire 618
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}
checkview -display result -2d -path ${imagedir}/${test_image}.png

21
tests/mkface/edges_to_faces/A7 Normal file
View File

@ -0,0 +1,21 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
restore [locate_data_file bug25926_before_offset.brep] s
eval compound [explode s e] c
edgestofaces result c
checkshape result
checknbshapes result -face 66 -wire 66
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}
checkview -display result -2d -path ${imagedir}/${test_image}.png

21
tests/mkface/edges_to_faces/A8 Normal file
View File

@ -0,0 +1,21 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
restore [locate_data_file bug26917_dom-8092.brep] s
eval compound [explode s e] c
edgestofaces result c
checkshape result
checknbshapes result -face 661 -wire 691
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}
checkview -display result -2d -path ${imagedir}/${test_image}.png

21
tests/mkface/edges_to_faces/A9 Normal file
View File

@ -0,0 +1,21 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
restore [locate_data_file bug26917_rm-104_input_3.brep] s
eval compound [explode s e] c
edgestofaces result c
checkshape result
checknbshapes result -face 2357 -wire 2575
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}
checkview -display result -2d -path ${imagedir}/${test_image}.png

20
tests/mkface/edges_to_faces/B1 Normal file
View File

@ -0,0 +1,20 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
restore [locate_data_file bug28426_edges_0.brep] c
edgestofaces result c
checkshape result
checknbshapes result -face 7 -wire 7
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}
checkview -display result -2d -path ${imagedir}/${test_image}.png

20
tests/mkface/edges_to_faces/B2 Normal file
View File

@ -0,0 +1,20 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
restore [locate_data_file bug28426_edges_1.brep] c
edgestofaces result c
checkshape result
checknbshapes result -face 8 -wire 8
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}
checkview -display result -2d -path ${imagedir}/${test_image}.png

20
tests/mkface/edges_to_faces/B3 Normal file
View File

@ -0,0 +1,20 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
restore [locate_data_file bug28426_edges_2.brep] c
edgestofaces result c
checkshape result
checknbshapes result -face 7 -wire 7
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}
checkview -display result -2d -path ${imagedir}/${test_image}.png

20
tests/mkface/edges_to_faces/B4 Normal file
View File

@ -0,0 +1,20 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
restore [locate_data_file bug28426_edges_3.brep] c
edgestofaces result c
checkshape result
checknbshapes result -face 7 -wire 7
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}
checkview -display result -2d -path ${imagedir}/${test_image}.png

20
tests/mkface/edges_to_faces/B5 Normal file
View File

@ -0,0 +1,20 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
restore [locate_data_file bug28426_edges_4.brep] c
edgestofaces result c
checkshape result
checknbshapes result -face 9 -wire 9
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}
checkview -display result -2d -path ${imagedir}/${test_image}.png

20
tests/mkface/edges_to_faces/B6 Normal file
View File

@ -0,0 +1,20 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
restore [locate_data_file bug28426_edges_5.brep] c
edgestofaces result c
checkshape result
checknbshapes result -face 10 -wire 10
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}
checkview -display result -2d -path ${imagedir}/${test_image}.png

20
tests/mkface/edges_to_faces/B7 Normal file
View File

@ -0,0 +1,20 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
restore [locate_data_file bug28426_edges_6.brep] c
edgestofaces result c
checkshape result
checknbshapes result -face 13 -wire 13
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}
checkview -display result -2d -path ${imagedir}/${test_image}.png

20
tests/mkface/edges_to_faces/B8 Normal file
View File

@ -0,0 +1,20 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
restore [locate_data_file bug28426_edges_7.brep] c
edgestofaces result c
checkshape result
checknbshapes result -face 10 -wire 10
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}
checkview -display result -2d -path ${imagedir}/${test_image}.png

20
tests/mkface/edges_to_faces/B9 Normal file
View File

@ -0,0 +1,20 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
restore [locate_data_file bug28426_edges_8.brep] c
edgestofaces result c
checkshape result
checknbshapes result -face 10 -wire 10
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}
checkview -display result -2d -path ${imagedir}/${test_image}.png

20
tests/mkface/edges_to_faces/C1 Normal file
View File

@ -0,0 +1,20 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
restore [locate_data_file bug28426_edges_9.brep] c
edgestofaces result c
checkshape result
checknbshapes result -face 12 -wire 12
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}
checkview -display result -2d -path ${imagedir}/${test_image}.png

20
tests/mkface/edges_to_faces/C2 Normal file
View File

@ -0,0 +1,20 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
restore [locate_data_file bug28426_edges_10.brep] c
edgestofaces result c
checkshape result
checknbshapes result -face 20 -wire 21
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}
checkview -display result -2d -path ${imagedir}/${test_image}.png

20
tests/mkface/edges_to_faces/C3 Normal file
View File

@ -0,0 +1,20 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
restore [locate_data_file bug28426_edges_11.brep] c
edgestofaces result c
checkshape result
checknbshapes result -face 19 -wire 19
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}
checkview -display result -2d -path ${imagedir}/${test_image}.png

20
tests/mkface/edges_to_faces/C4 Normal file
View File

@ -0,0 +1,20 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
restore [locate_data_file bug28426_edges_12.brep] c
edgestofaces result c
checkshape result
checknbshapes result -face 14 -wire 14
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}
checkview -display result -2d -path ${imagedir}/${test_image}.png

20
tests/mkface/edges_to_faces/C5 Normal file
View File

@ -0,0 +1,20 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
restore [locate_data_file bug28426_edges_13.brep] c
edgestofaces result c
checkshape result
checknbshapes result -face 13 -wire 13
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}
checkview -display result -2d -path ${imagedir}/${test_image}.png

20
tests/mkface/edges_to_faces/C6 Normal file
View File

@ -0,0 +1,20 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
restore [locate_data_file bug28426_edges_14.brep] c
edgestofaces result c
checkshape result
checknbshapes result -face 15 -wire 15
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}
checkview -display result -2d -path ${imagedir}/${test_image}.png

20
tests/mkface/edges_to_faces/C7 Normal file
View File

@ -0,0 +1,20 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
restore [locate_data_file bug28426_edges_15.brep] c
edgestofaces result c
checkshape result
checknbshapes result -face 17 -wire 17
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}
checkview -display result -2d -path ${imagedir}/${test_image}.png

20
tests/mkface/edges_to_faces/C8 Normal file
View File

@ -0,0 +1,20 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
restore [locate_data_file bug28426_edges_16.brep] c
edgestofaces result c
checkshape result
checknbshapes result -face 46 -wire 48
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}
checkview -display result -2d -path ${imagedir}/${test_image}.png

20
tests/mkface/edges_to_faces/C9 Normal file
View File

@ -0,0 +1,20 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
restore [locate_data_file bug28426_edges_17.brep] c
edgestofaces result c
checkshape result
checknbshapes result -face 14 -wire 16
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}
checkview -display result -2d -path ${imagedir}/${test_image}.png

20
tests/mkface/edges_to_faces/D1 Normal file
View File

@ -0,0 +1,20 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
restore [locate_data_file bug28426_edges_18.brep] c
edgestofaces result c
checkshape result
checknbshapes result -face 5 -wire 5
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}
checkview -display result -2d -path ${imagedir}/${test_image}.png

20
tests/mkface/edges_to_faces/D2 Normal file
View File

@ -0,0 +1,20 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
restore [locate_data_file bug28426_edges_19.brep] c
edgestofaces result c
checkshape result
checknbshapes result -face 10 -wire 10
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}
checkview -display result -2d -path ${imagedir}/${test_image}.png

20
tests/mkface/edges_to_faces/D3 Normal file
View File

@ -0,0 +1,20 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
restore [locate_data_file bug28426_edges_20.brep] c
edgestofaces result c
checkshape result
checknbshapes result -face 11 -wire 11
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}
checkview -display result -2d -path ${imagedir}/${test_image}.png

20
tests/mkface/edges_to_faces/D4 Normal file
View File

@ -0,0 +1,20 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
restore [locate_data_file bug28426_edges_21.brep] c
edgestofaces result c
checkshape result
checknbshapes result -face 10 -wire 10
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}
checkview -display result -2d -path ${imagedir}/${test_image}.png

21
tests/mkface/edges_to_faces/D5 Normal file
View File

@ -0,0 +1,21 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
restore [locate_data_file bug28284.brep] s
eval compound [explode s e] c
edgestofaces result c
checkshape result
checknbshapes result -face 11478 -wire 11478
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}
checkview -display result -2d -path ${imagedir}/${test_image}.png

19
tests/mkface/edges_to_faces/D6 Normal file
View File

@ -0,0 +1,19 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
circle c 0 0 0 0 0 1 10
mkedge e c
edgestofaces result e
checkshape result
checknbshapes result -face 1 -wire 1
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}

25
tests/mkface/edges_to_faces/D7 Normal file
View File

@ -0,0 +1,25 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
circle c1 0 0 0 0 0 1 10
circle c2 5 0 0 0 0 1 10
circle c3 5 5 0 0 0 1 10
mkedge e1 c1
mkedge e2 c2
mkedge e3 c3
compound e1 e2 e3 c
edgestofaces result c
checkshape result
checknbshapes result -face 7 -wire 7
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}

26
tests/mkface/edges_to_faces/D8 Normal file
View File

@ -0,0 +1,26 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
circle c1 0 0 0 0 0 1 10
circle c2 -2 0 0 0 0 1 5
circle c3 2 0 0 0 0 1 5
mkedge e1 c1
mkedge e2 c2
mkedge e3 c3
compound e1 e2 e3 c
edgestofaces result c
checkshape result
checknbshapes result -face 4 -wire 5
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}

21
tests/mkface/edges_to_faces/D9 Normal file
View File

@ -0,0 +1,21 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
box b1 10 10 10
box b2 10 0 0 10 10 5
eval compound [explode b1 e] [explode b2 e] c
nurbsconvert c c
edgestofaces result c
checkshape result
checknbshapes result -face 12 -wire 12
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}

33
tests/mkface/edges_to_faces/E1 Normal file
View File

@ -0,0 +1,33 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
circle c 0 0 0 0 0 1 10
line l 0 0 0 1 0 0
mkedge ec c
mkedge el l -15 15
compound el ec c
edgestofaces result1 c
compound ec el c
edgestofaces result c
checkshape result1
checkshape result
checknbshapes result1 -face 2 -wire 2
checknbshapes result -face 2 -wire 2
if { [regexp "This shape seems to be OK" [bopcheck result1]] != 1 } {
puts "Error : The result is self-interfered"
}
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}

30
tests/mkface/edges_to_faces/E2 Normal file
View File

@ -0,0 +1,30 @@
puts "========"
puts "OCC28426"
puts "========"
puts ""
#################################################
# Implementation of the EdgesToFaces function
#################################################
circle cx 0 0 0 1 0 0 10
circle cy 0 0 0 0 1 0 10
circle cz 0 0 0 0 0 1 10
line lx 0 0 0 1 0 0
line ly 0 0 0 0 1 0
line lz 0 0 0 0 0 1
mkedge ex cx
mkedge ey cy
mkedge ez cz
mkedge elx lx -11 11
mkedge ely ly -11 11
mkedge elz lz -11 11
compound ex ey ez elx ely elz c
edgestofaces result c
checkshape result
checknbshapes result -face 12 -wire 12
if { [regexp "This shape seems to be OK" [bopcheck result]] != 1 } {
puts "Error : The result is self-interfered"
}

1
tests/mkface/grids.list
View File

@ -4,3 +4,4 @@
004 after_extsurf_and_trim
005 after_revsurf_and_offset
006 mkplane
007 edges_to_faces