mirror of
https://git.dev.opencascade.org/repos/occt.git
synced 2025-06-10 11:34:06 +03:00
a5a7b3185b
Update empty method guards to new style with regex (see PR). Used clang-format 18.1.8. New actions to validate code formatting is added. Update .clang-format with disabling of include sorting. It is temporary changes, then include will be sorted. Apply formatting for /src and /tools folder. The files with .hxx,.cxx,.lxx,.h,.pxx,.hpp,*.cpp extensions.
1702 lines
42 KiB
C++
1702 lines
42 KiB
C++
// Created by: Eugeny MALTCHIKOV
|
|
// Copyright (c) 2015 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 <BOPTest.hxx>
|
|
#include <BOPTest_Objects.hxx>
|
|
#include <BOPTest_DrawableShape.hxx>
|
|
|
|
#include <Draw.hxx>
|
|
#include <Draw_Color.hxx>
|
|
|
|
#include <DBRep.hxx>
|
|
|
|
#include <BRep_Builder.hxx>
|
|
|
|
#include <TopoDS_Compound.hxx>
|
|
|
|
#include <TopExp_Explorer.hxx>
|
|
|
|
#include <BOPDS_DS.hxx>
|
|
#include <BOPDS_Iterator.hxx>
|
|
#include <BOPDS_MapOfCommonBlock.hxx>
|
|
|
|
#include <BOPAlgo_Builder.hxx>
|
|
#include <BOPAlgo_BuilderFace.hxx>
|
|
#include <BOPAlgo_BuilderSolid.hxx>
|
|
|
|
#include <TopTools_DataMapOfShapeShape.hxx>
|
|
#include <TopTools_DataMapOfShapeListOfShape.hxx>
|
|
|
|
#include <IntTools_Context.hxx>
|
|
|
|
static void GetTypeByName(const char* theName, TopAbs_ShapeEnum& theType);
|
|
static void GetNameByType(const TopAbs_ShapeEnum& theType, char* theName);
|
|
|
|
template <class InterfType>
|
|
static void DumpInterfs(const NCollection_Vector<InterfType>& theVInterf, Draw_Interpretor& di);
|
|
|
|
template <class InterfType>
|
|
static void SearchNewIndex(const char* theCType,
|
|
const Standard_Integer theInd,
|
|
const NCollection_Vector<InterfType>& theVInterf,
|
|
Draw_Interpretor& di);
|
|
static Standard_Integer bopfinfo(Draw_Interpretor& di,
|
|
Standard_Integer n,
|
|
const char** a,
|
|
const Standard_Integer iPriz);
|
|
|
|
// commands
|
|
// 1. filler commands
|
|
// 1.1 DS commands
|
|
static Standard_Integer bopds(Draw_Interpretor&, Standard_Integer, const char**);
|
|
static Standard_Integer bopiterator(Draw_Interpretor&, Standard_Integer, const char**);
|
|
static Standard_Integer bopinterf(Draw_Interpretor&, Standard_Integer, const char**);
|
|
static Standard_Integer bopnews(Draw_Interpretor&, Standard_Integer, const char**);
|
|
static Standard_Integer bopwho(Draw_Interpretor&, Standard_Integer, const char**);
|
|
static Standard_Integer bopindex(Draw_Interpretor&, Standard_Integer, const char**);
|
|
static Standard_Integer bopsd(Draw_Interpretor&, Standard_Integer, const char**);
|
|
static Standard_Integer bopsc(Draw_Interpretor&, Standard_Integer, const char**);
|
|
|
|
// 1.2 pave blocks commands
|
|
static Standard_Integer boppb(Draw_Interpretor&, Standard_Integer, const char**);
|
|
static Standard_Integer bopcb(Draw_Interpretor&, Standard_Integer, const char**);
|
|
static Standard_Integer bopsp(Draw_Interpretor&, Standard_Integer, const char**);
|
|
|
|
// 1.3 face info commands
|
|
static Standard_Integer bopfon(Draw_Interpretor&, Standard_Integer, const char**);
|
|
static Standard_Integer bopfin(Draw_Interpretor&, Standard_Integer, const char**);
|
|
static Standard_Integer bopfsc(Draw_Interpretor&, Standard_Integer, const char**);
|
|
static Standard_Integer bopfav(Draw_Interpretor&, Standard_Integer, const char**);
|
|
|
|
// 2. builder commands
|
|
// 2.1 images commands
|
|
static Standard_Integer bopimage(Draw_Interpretor&, Standard_Integer, const char**);
|
|
static Standard_Integer boporigin(Draw_Interpretor&, Standard_Integer, const char**);
|
|
static Standard_Integer bopfsd(Draw_Interpretor&, Standard_Integer, const char**);
|
|
|
|
// 2.2 building faces
|
|
static Standard_Integer bopbface(Draw_Interpretor&, Standard_Integer, const char**);
|
|
// 2.3 building solids
|
|
static Standard_Integer bopbsolid(Draw_Interpretor&, Standard_Integer, const char**);
|
|
|
|
//=================================================================================================
|
|
|
|
void BOPTest::DebugCommands(Draw_Interpretor& theCommands)
|
|
{
|
|
static Standard_Boolean done = Standard_False;
|
|
if (done)
|
|
return;
|
|
done = Standard_True;
|
|
// Chapter's name
|
|
const char* g = "BOPTest commands";
|
|
// Commands
|
|
theCommands.Add("bopds",
|
|
"Shows the shapes from DS. Use: bopds [v/e/w/f/sh/s/cs/c]",
|
|
__FILE__,
|
|
bopds,
|
|
g);
|
|
theCommands.Add("bopiterator",
|
|
"Shows the pairs of interfered shapes. Use: bopiterator [type1 type2]",
|
|
__FILE__,
|
|
bopiterator,
|
|
g);
|
|
theCommands.Add("bopinterf",
|
|
"Shows interferences of given type. Use: bopinterf type1 type2",
|
|
__FILE__,
|
|
bopinterf,
|
|
g);
|
|
theCommands.Add("bopnews",
|
|
"Shows the newly created shapes. Use: bopnews [v,e,f]",
|
|
__FILE__,
|
|
bopnews,
|
|
g);
|
|
theCommands.Add("bopwho",
|
|
"Shows where the new shape was created. Use: bopwho #",
|
|
__FILE__,
|
|
bopwho,
|
|
g);
|
|
theCommands.Add("bopindex",
|
|
"Gets the index of the shape in the DS. Use: bopindex s",
|
|
__FILE__,
|
|
bopindex,
|
|
g);
|
|
theCommands.Add("bopsd", "Gets the Same domain shape. Use: bopsd #", __FILE__, bopsd, g);
|
|
theCommands.Add("bopsc", "Shows the section curves. Use: bopsc [nF1 [nF2]]", __FILE__, bopsc, g);
|
|
theCommands.Add("boppb",
|
|
"Shows information about pave blocks. Use: boppb [#e]",
|
|
__FILE__,
|
|
boppb,
|
|
g);
|
|
theCommands.Add("bopcb",
|
|
"Shows information about common blocks. Use: bopcb [#e]",
|
|
__FILE__,
|
|
bopcb,
|
|
g);
|
|
theCommands.Add("bopsp", "Shows the splits of edges. Use: bopsp [#e]", __FILE__, bopsp, g);
|
|
theCommands.Add("bopfon",
|
|
"Shows ON information for the face. Use: bopfon #f",
|
|
__FILE__,
|
|
bopfon,
|
|
g);
|
|
theCommands.Add("bopfin",
|
|
"Shows IN information for the face. Use: bopfin #f",
|
|
__FILE__,
|
|
bopfin,
|
|
g);
|
|
theCommands.Add("bopfsc",
|
|
"Shows SC information for the face. Use: bopfsc #f",
|
|
__FILE__,
|
|
bopfsc,
|
|
g);
|
|
theCommands.Add("bopfav",
|
|
"Shows information about alone vertices for the face. Use: bopfav #f",
|
|
__FILE__,
|
|
bopfav,
|
|
g);
|
|
theCommands.Add("bopimage",
|
|
"Shows split parts of the shape. Use: bopimage s",
|
|
__FILE__,
|
|
bopimage,
|
|
g);
|
|
theCommands.Add("boporigin",
|
|
"Shows the original shape for the shape. Use: boporigin s",
|
|
__FILE__,
|
|
boporigin,
|
|
g);
|
|
theCommands.Add("bopfsd", "Shows SD faces for the face: Use: bopfsd f", __FILE__, bopfsd, g);
|
|
theCommands.Add("bopbsolid",
|
|
"Build solids from set of shared faces. Use: bopbsolid sr cx",
|
|
__FILE__,
|
|
bopbsolid,
|
|
g);
|
|
theCommands.Add("bopbface",
|
|
"Splits the face by set of shared edges. Use: bopbface fr cx",
|
|
__FILE__,
|
|
bopbface,
|
|
g);
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
Standard_Integer bopds(Draw_Interpretor& di, Standard_Integer n, const char** a)
|
|
{
|
|
if (n > 2)
|
|
{
|
|
di << "Shows the shapes from DS. Use: bopds [v/e/w/f/sh/s/cs/c]\n";
|
|
return 1;
|
|
}
|
|
//
|
|
BOPDS_PDS pDS = BOPTest_Objects::PDS();
|
|
if (!pDS)
|
|
{
|
|
di << " prepare PaveFiller first\n";
|
|
return 1;
|
|
}
|
|
//
|
|
char buf[32];
|
|
Standard_CString aText;
|
|
Standard_Integer i, aNbS;
|
|
TopAbs_ShapeEnum aType, aTypeShape;
|
|
Draw_Color aTextColor(Draw_cyan);
|
|
//
|
|
BOPDS_DS& aDS = *pDS;
|
|
aNbS = aDS.NbSourceShapes();
|
|
//
|
|
aType = TopAbs_SHAPE;
|
|
if (n == 2)
|
|
{
|
|
GetTypeByName(a[1], aType);
|
|
}
|
|
//
|
|
for (i = 0; i < aNbS; ++i)
|
|
{
|
|
const BOPDS_ShapeInfo& aSI = aDS.ShapeInfo(i);
|
|
const TopoDS_Shape& aS = aSI.Shape();
|
|
aTypeShape = aSI.ShapeType();
|
|
if (n == 1)
|
|
{
|
|
if (aTypeShape == TopAbs_COMPOUND || aTypeShape == TopAbs_COMPSOLID
|
|
|| aTypeShape == TopAbs_SOLID || aTypeShape == TopAbs_SHELL || aTypeShape == TopAbs_WIRE)
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (aTypeShape != aType)
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
//
|
|
Sprintf(buf, "z%d", i);
|
|
aText = buf;
|
|
Handle(BOPTest_DrawableShape) aDShape = new BOPTest_DrawableShape(aS, aText, aTextColor);
|
|
Draw::Set(aText, aDShape);
|
|
}
|
|
//
|
|
return 0;
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
Standard_Integer bopiterator(Draw_Interpretor& di, Standard_Integer n, const char** a)
|
|
{
|
|
if (n != 1 && n != 3)
|
|
{
|
|
di << "Shows the pairs of interfered shapes. Use: bopiterator [type1 type2]\n";
|
|
return 1;
|
|
}
|
|
//
|
|
BOPDS_PDS pDS = BOPTest_Objects::PDS();
|
|
if (!pDS)
|
|
{
|
|
di << " prepare PaveFiller first\n";
|
|
return 1;
|
|
}
|
|
//
|
|
Standard_Integer n1, n2;
|
|
char buf[64], aST1[10], aST2[10];
|
|
BOPDS_Iterator aIt;
|
|
//
|
|
Handle(IntTools_Context) aCtx = new IntTools_Context();
|
|
|
|
BOPDS_DS& aDS = *pDS;
|
|
aIt.SetDS(&aDS);
|
|
aIt.Prepare(aCtx, BOPTest_Objects::UseOBB(), BOPTest_Objects::FuzzyValue());
|
|
//
|
|
if (n == 1)
|
|
{
|
|
// type has not been defined. show all pairs
|
|
Standard_Integer i, j;
|
|
TopAbs_ShapeEnum aT[4] = {TopAbs_VERTEX, TopAbs_EDGE, TopAbs_FACE, TopAbs_SOLID};
|
|
for (i = 0; i < 4; ++i)
|
|
{
|
|
GetNameByType(aT[i], aST1);
|
|
//
|
|
for (j = i; j < 4; ++j)
|
|
{
|
|
GetNameByType(aT[j], aST2);
|
|
//
|
|
aIt.Initialize(aT[i], aT[j]);
|
|
for (; aIt.More(); aIt.Next())
|
|
{
|
|
aIt.Value(n1, n2);
|
|
//
|
|
Sprintf(buf, "%s/%s: (z%d z%d)\n", aST1, aST2, n1, n2);
|
|
di << buf;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (n == 3)
|
|
{
|
|
TopAbs_ShapeEnum aT1, aT2;
|
|
//
|
|
GetTypeByName(a[1], aT1);
|
|
GetTypeByName(a[2], aT2);
|
|
//
|
|
GetNameByType(aT1, aST1);
|
|
GetNameByType(aT2, aST2);
|
|
//
|
|
aIt.Initialize(aT1, aT2);
|
|
for (; aIt.More(); aIt.Next())
|
|
{
|
|
aIt.Value(n1, n2);
|
|
//
|
|
Sprintf(buf, "%s/%s: (z%d z%d)\n", aST1, aST2, n1, n2);
|
|
di << buf;
|
|
}
|
|
}
|
|
//
|
|
return 0;
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
Standard_Integer bopinterf(Draw_Interpretor& di, Standard_Integer n, const char** a)
|
|
{
|
|
if (n != 3)
|
|
{
|
|
di << "Shows interferences of given type. Use: bopinterf type1 type2\n";
|
|
return 1;
|
|
}
|
|
//
|
|
BOPDS_PDS pDS = BOPTest_Objects::PDS();
|
|
if (!pDS)
|
|
{
|
|
di << " prepare PaveFiller first\n";
|
|
return 1;
|
|
}
|
|
//
|
|
TopAbs_ShapeEnum aT1, aT2;
|
|
GetTypeByName(a[1], aT1);
|
|
GetTypeByName(a[2], aT2);
|
|
//
|
|
if (aT1 == TopAbs_VERTEX && aT2 == TopAbs_VERTEX)
|
|
{
|
|
di << "V/V: ";
|
|
DumpInterfs<BOPDS_InterfVV>(pDS->InterfVV(), di);
|
|
}
|
|
else if ((aT1 == TopAbs_VERTEX && aT2 == TopAbs_EDGE)
|
|
|| (aT2 == TopAbs_VERTEX && aT1 == TopAbs_EDGE))
|
|
{
|
|
di << "V/E: ";
|
|
DumpInterfs<BOPDS_InterfVE>(pDS->InterfVE(), di);
|
|
}
|
|
else if (aT1 == TopAbs_EDGE && aT2 == TopAbs_EDGE)
|
|
{
|
|
di << "E/E: ";
|
|
DumpInterfs<BOPDS_InterfEE>(pDS->InterfEE(), di);
|
|
}
|
|
else if ((aT1 == TopAbs_VERTEX && aT2 == TopAbs_FACE)
|
|
|| (aT2 == TopAbs_VERTEX && aT1 == TopAbs_FACE))
|
|
{
|
|
di << "V/F: ";
|
|
DumpInterfs<BOPDS_InterfVF>(pDS->InterfVF(), di);
|
|
}
|
|
else if ((aT1 == TopAbs_EDGE && aT2 == TopAbs_FACE) || (aT2 == TopAbs_EDGE && aT1 == TopAbs_FACE))
|
|
{
|
|
di << "E/F: ";
|
|
DumpInterfs<BOPDS_InterfEF>(pDS->InterfEF(), di);
|
|
}
|
|
else if (aT1 == TopAbs_FACE && aT2 == TopAbs_FACE)
|
|
{
|
|
di << "F/F: ";
|
|
DumpInterfs<BOPDS_InterfFF>(pDS->InterfFF(), di);
|
|
}
|
|
else if ((aT1 == TopAbs_VERTEX && aT2 == TopAbs_SOLID)
|
|
|| (aT2 == TopAbs_VERTEX && aT1 == TopAbs_SOLID))
|
|
{
|
|
di << "V/S: ";
|
|
DumpInterfs<BOPDS_InterfVZ>(pDS->InterfVZ(), di);
|
|
}
|
|
else if ((aT1 == TopAbs_EDGE && aT2 == TopAbs_SOLID)
|
|
|| (aT2 == TopAbs_EDGE && aT1 == TopAbs_SOLID))
|
|
{
|
|
di << "E/S: ";
|
|
DumpInterfs<BOPDS_InterfEZ>(pDS->InterfEZ(), di);
|
|
}
|
|
else if ((aT1 == TopAbs_FACE && aT2 == TopAbs_SOLID)
|
|
|| (aT2 == TopAbs_FACE && aT1 == TopAbs_SOLID))
|
|
{
|
|
di << "F/S: ";
|
|
DumpInterfs<BOPDS_InterfFZ>(pDS->InterfFZ(), di);
|
|
}
|
|
else if (aT1 == TopAbs_SOLID && aT2 == TopAbs_SOLID)
|
|
{
|
|
di << "S/S: ";
|
|
DumpInterfs<BOPDS_InterfZZ>(pDS->InterfZZ(), di);
|
|
}
|
|
//
|
|
return 0;
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
Standard_Integer bopwho(Draw_Interpretor& di, Standard_Integer n, const char** a)
|
|
{
|
|
if (n != 2)
|
|
{
|
|
di << "Shows where the new shape was created. Use: bopwho #\n";
|
|
return 1;
|
|
}
|
|
//
|
|
BOPDS_PDS pDS = BOPTest_Objects::PDS();
|
|
if (!pDS)
|
|
{
|
|
di << " prepare PaveFiller first\n";
|
|
return 0;
|
|
}
|
|
//
|
|
Standard_Integer ind = Draw::Atoi(a[1]);
|
|
if (ind <= 0)
|
|
{
|
|
di << " Index must be grater than 0\n";
|
|
return 1;
|
|
}
|
|
//
|
|
Standard_Integer i1, i2;
|
|
//
|
|
i1 = 0;
|
|
i2 = pDS->NbShapes();
|
|
if (ind < i1 || ind > i2)
|
|
{
|
|
di << " DS does not contain the shape\n";
|
|
return 1;
|
|
}
|
|
//
|
|
if (!pDS->IsNewShape(ind))
|
|
{
|
|
Standard_Integer iRank = pDS->Rank(ind);
|
|
di << " Rank: " << iRank << "\n";
|
|
return 0;
|
|
}
|
|
//
|
|
// the shape is new
|
|
di << "the shape is new\n";
|
|
//
|
|
const BOPDS_ShapeInfo& aSI = pDS->ShapeInfo(ind);
|
|
if (aSI.ShapeType() != TopAbs_VERTEX)
|
|
{
|
|
return 0;
|
|
}
|
|
// search among interfs
|
|
BOPDS_VectorOfInterfVV& aVVs = pDS->InterfVV();
|
|
BOPDS_VectorOfInterfVE& aVEs = pDS->InterfVE();
|
|
BOPDS_VectorOfInterfEE& aEEs = pDS->InterfEE();
|
|
BOPDS_VectorOfInterfVF& aVFs = pDS->InterfVF();
|
|
BOPDS_VectorOfInterfEF& aEFs = pDS->InterfEF();
|
|
//
|
|
SearchNewIndex<BOPDS_InterfVV>("V/V: ", ind, aVVs, di);
|
|
SearchNewIndex<BOPDS_InterfVE>("V/E: ", ind, aVEs, di);
|
|
SearchNewIndex<BOPDS_InterfEE>("E/E: ", ind, aEEs, di);
|
|
SearchNewIndex<BOPDS_InterfVF>("V/F: ", ind, aVFs, di);
|
|
SearchNewIndex<BOPDS_InterfEF>("E/F: ", ind, aEFs, di);
|
|
//
|
|
//--------------------------------------FF
|
|
char buf[64];
|
|
Standard_Boolean bFound;
|
|
Standard_Integer i, n1, n2, k, aNb, aNbC, aNbP, nV1, nV2;
|
|
BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
|
|
//
|
|
bFound = Standard_False;
|
|
BOPDS_VectorOfInterfFF& aFFs = pDS->InterfFF();
|
|
aNb = aFFs.Length();
|
|
for (i = 0; i < aNb; ++i)
|
|
{
|
|
const BOPDS_InterfFF& anInt = aFFs(i);
|
|
anInt.Indices(n1, n2);
|
|
//
|
|
const BOPDS_VectorOfCurve& aVNC = anInt.Curves();
|
|
aNbC = aVNC.Length();
|
|
for (k = 0; k < aNbC; ++k)
|
|
{
|
|
const BOPDS_Curve& aNC = aVNC(k);
|
|
const BOPDS_ListOfPaveBlock& aLPB = aNC.PaveBlocks();
|
|
aItLPB.Initialize(aLPB);
|
|
for (; aItLPB.More(); aItLPB.Next())
|
|
{
|
|
const Handle(BOPDS_PaveBlock)& aPB = aItLPB.Value();
|
|
aPB->Indices(nV1, nV2);
|
|
if (ind == nV1 || ind == nV2)
|
|
{
|
|
if (!bFound)
|
|
{
|
|
di << " FF curves: ";
|
|
bFound = Standard_True;
|
|
}
|
|
Sprintf(buf, "(%d, %d) ", n1, n2);
|
|
di << buf;
|
|
break;
|
|
}
|
|
}
|
|
} // for (k=0; k<aNbC; ++k)
|
|
if (bFound)
|
|
{
|
|
di << "\n";
|
|
}
|
|
//
|
|
bFound = Standard_False;
|
|
const BOPDS_VectorOfPoint& aVNP = anInt.Points();
|
|
aNbP = aVNP.Length();
|
|
for (k = 0; k < aNbP; ++k)
|
|
{
|
|
const BOPDS_Point& aNP = aVNP(k);
|
|
nV1 = aNP.Index();
|
|
if (ind == nV1)
|
|
{
|
|
if (!bFound)
|
|
{
|
|
di << " FF points: ";
|
|
bFound = Standard_True;
|
|
}
|
|
sprintf(buf, "(%d, %d) ", n1, n2);
|
|
di << buf;
|
|
}
|
|
} // for (k=0; k<aNbP; ++k)
|
|
if (bFound)
|
|
{
|
|
di << "\n";
|
|
}
|
|
}
|
|
//
|
|
return 0;
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
Standard_Integer bopnews(Draw_Interpretor& di, Standard_Integer n, const char** a)
|
|
{
|
|
if (n != 2)
|
|
{
|
|
di << "Shows the newly created shapes. Use: bopnews v/e/f\n";
|
|
return 1;
|
|
}
|
|
//
|
|
BOPDS_PDS pDS = BOPTest_Objects::PDS();
|
|
if (!pDS)
|
|
{
|
|
di << " prepare PaveFiller first\n";
|
|
return 1;
|
|
}
|
|
//
|
|
TopAbs_ShapeEnum aType;
|
|
GetTypeByName(a[1], aType);
|
|
//
|
|
if (!(aType == TopAbs_VERTEX || aType == TopAbs_EDGE || aType == TopAbs_FACE))
|
|
{
|
|
di << "Use: bopnews v/e/f\n";
|
|
return 1;
|
|
}
|
|
//
|
|
char buf[32];
|
|
Standard_CString aText;
|
|
Standard_Boolean bFound;
|
|
Standard_Integer i, i1, i2;
|
|
Draw_Color aTextColor(Draw_cyan);
|
|
Handle(BOPTest_DrawableShape) aDShape;
|
|
//
|
|
bFound = Standard_False;
|
|
i1 = pDS->NbSourceShapes();
|
|
i2 = pDS->NbShapes();
|
|
for (i = i1; i < i2; ++i)
|
|
{
|
|
const BOPDS_ShapeInfo& aSI = pDS->ShapeInfo(i);
|
|
if (aSI.ShapeType() == aType)
|
|
{
|
|
const TopoDS_Shape& aS = aSI.Shape();
|
|
//
|
|
sprintf(buf, "z%d", i);
|
|
aText = buf;
|
|
aDShape = new BOPTest_DrawableShape(aS, aText, aTextColor);
|
|
Draw::Set(aText, aDShape);
|
|
//
|
|
sprintf(buf, "z%d ", i);
|
|
di << buf;
|
|
//
|
|
bFound = Standard_True;
|
|
}
|
|
}
|
|
//
|
|
if (bFound)
|
|
{
|
|
di << "\n";
|
|
}
|
|
else
|
|
{
|
|
di << " No new shapes found\n";
|
|
}
|
|
//
|
|
return 0;
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
Standard_Integer bopindex(Draw_Interpretor& di, Standard_Integer n, const char** a)
|
|
{
|
|
if (n != 2)
|
|
{
|
|
di << "Gets the index of the shape in the DS. Use: bopindex s\n";
|
|
return 1;
|
|
}
|
|
//
|
|
BOPDS_PDS pDS = BOPTest_Objects::PDS();
|
|
if (!pDS)
|
|
{
|
|
di << " prepare PaveFiller first\n";
|
|
return 1;
|
|
}
|
|
//
|
|
TopoDS_Shape aS = DBRep::Get(a[1]);
|
|
if (aS.IsNull())
|
|
{
|
|
di << a[1] << " is a null shape\n";
|
|
return 1;
|
|
}
|
|
//
|
|
Standard_Integer ind = pDS->Index(aS);
|
|
Standard_Boolean bFound = (ind > 0);
|
|
if (bFound)
|
|
{
|
|
di << " Index: " << ind << "\n";
|
|
}
|
|
else
|
|
{
|
|
di << " DS does not contain the shape\n";
|
|
}
|
|
//
|
|
return 0;
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
Standard_Integer bopsd(Draw_Interpretor& di, Standard_Integer n, const char** a)
|
|
{
|
|
if (n != 2)
|
|
{
|
|
di << "Gets the Same domain shape. Use: bopsd #\n";
|
|
return 0;
|
|
}
|
|
//
|
|
BOPDS_PDS pDS = BOPTest_Objects::PDS();
|
|
if (!pDS)
|
|
{
|
|
di << " prepare PaveFiller first\n";
|
|
return 0;
|
|
}
|
|
//
|
|
char buf[32];
|
|
Standard_Boolean bHasSD;
|
|
Standard_Integer ind, i1, i2, iSD;
|
|
//
|
|
ind = Draw::Atoi(a[1]);
|
|
//
|
|
i1 = 0;
|
|
i2 = pDS->NbShapes();
|
|
if (ind < i1 || ind > i2)
|
|
{
|
|
di << " DS does not contain the shape\n";
|
|
return 0;
|
|
}
|
|
//
|
|
bHasSD = pDS->HasShapeSD(ind, iSD);
|
|
if (bHasSD)
|
|
{
|
|
Sprintf(buf, " Shape %d has SD shape %d\n", ind, iSD);
|
|
di << buf;
|
|
}
|
|
else
|
|
{
|
|
Sprintf(buf, " Shape: %d has no SD shape\n", ind);
|
|
di << buf;
|
|
}
|
|
//
|
|
return 0;
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
Standard_Integer bopsc(Draw_Interpretor& di, Standard_Integer n, const char** a)
|
|
{
|
|
if (n > 3)
|
|
{
|
|
di.PrintHelp(a[0]);
|
|
return 1;
|
|
}
|
|
//
|
|
BOPDS_PDS pDS = BOPTest_Objects::PDS();
|
|
if (!pDS)
|
|
{
|
|
di << " prepare PaveFiller first\n";
|
|
return 0;
|
|
}
|
|
//
|
|
char buf[32];
|
|
Standard_CString aText;
|
|
Draw_Color aTextColor(Draw_cyan);
|
|
Standard_Integer nSF1, nSF2, nF1, nF2;
|
|
Standard_Integer aNb, j, iCnt, k, iPriz, aNbC, aNbP, nSp;
|
|
Standard_Integer iX;
|
|
Handle(BOPTest_DrawableShape) aDShape;
|
|
BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
|
|
//
|
|
nSF1 = nSF2 = -1;
|
|
if (n > 1)
|
|
nSF1 = Draw::Atoi(a[1]);
|
|
if (n > 2)
|
|
nSF2 = Draw::Atoi(a[2]);
|
|
|
|
BOPDS_VectorOfInterfFF& aFFs = pDS->InterfFF();
|
|
//
|
|
iCnt = 0;
|
|
iPriz = 0;
|
|
aNb = aFFs.Length();
|
|
for (j = 0; j < aNb; ++j)
|
|
{
|
|
const BOPDS_InterfFF& aFF = aFFs(j);
|
|
if (n == 3)
|
|
{
|
|
if (!aFF.Contains(nSF1) || !aFF.Contains(nSF2))
|
|
{
|
|
continue;
|
|
}
|
|
iPriz = 1;
|
|
}
|
|
else if (n == 2)
|
|
{
|
|
if (!aFF.Contains(nSF1))
|
|
continue;
|
|
}
|
|
//
|
|
aFF.Indices(nF1, nF2);
|
|
//
|
|
iX = 0;
|
|
const BOPDS_VectorOfCurve& aVNC = aFF.Curves();
|
|
aNbC = aVNC.Length();
|
|
for (k = 0; k < aNbC; ++k)
|
|
{
|
|
const BOPDS_Curve& aNC = aVNC(k);
|
|
const BOPDS_ListOfPaveBlock& aLPB = aNC.PaveBlocks();
|
|
aItLPB.Initialize(aLPB);
|
|
for (; aItLPB.More(); aItLPB.Next())
|
|
{
|
|
const Handle(BOPDS_PaveBlock)& aPB = aItLPB.Value();
|
|
if (!aPB->HasEdge(nSp))
|
|
{
|
|
continue;
|
|
}
|
|
//
|
|
if (!iX)
|
|
{
|
|
Sprintf(buf, "[%d %d] section edges: ", nF1, nF2);
|
|
di << buf;
|
|
iX = 1;
|
|
}
|
|
sprintf(buf, "t_%d_%d", k, nSp);
|
|
di << buf;
|
|
//
|
|
const TopoDS_Shape& aSp = pDS->Shape(nSp);
|
|
aText = buf;
|
|
aDShape = new BOPTest_DrawableShape(aSp, aText, aTextColor);
|
|
Draw::Set(aText, aDShape);
|
|
di << " ";
|
|
++iCnt;
|
|
}
|
|
}
|
|
if (iX)
|
|
{
|
|
di << "\n";
|
|
}
|
|
//
|
|
iX = 0;
|
|
const BOPDS_VectorOfPoint& aVNP = aFF.Points();
|
|
aNbP = aVNP.Length();
|
|
for (k = 0; k < aNbP; ++k)
|
|
{
|
|
const BOPDS_Point& aNP = aVNP(k);
|
|
nSp = aNP.Index();
|
|
if (nSp < 0)
|
|
{
|
|
continue;
|
|
}
|
|
if (!iX)
|
|
{
|
|
sprintf(buf, "[%d %d] section vertices: ", nF1, nF2);
|
|
di << buf;
|
|
iX = 1;
|
|
}
|
|
sprintf(buf, "p_%d_%d", k, nSp);
|
|
di << buf;
|
|
//
|
|
const TopoDS_Shape& aSp = pDS->Shape(nSp);
|
|
aText = buf;
|
|
aDShape = new BOPTest_DrawableShape(aSp, aText, aTextColor);
|
|
Draw::Set(aText, aDShape);
|
|
di << " ";
|
|
++iCnt;
|
|
}
|
|
if (iX)
|
|
{
|
|
di << "\n";
|
|
}
|
|
//
|
|
if (iPriz)
|
|
{
|
|
break;
|
|
}
|
|
} // for (j=0; j<aNb; ++j) {
|
|
//
|
|
if (iCnt)
|
|
{
|
|
di << "\n";
|
|
}
|
|
else
|
|
{
|
|
di << " no sections found\n";
|
|
}
|
|
//
|
|
return 0;
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
Standard_Integer boppb(Draw_Interpretor& di, Standard_Integer n, const char** a)
|
|
{
|
|
if (n > 2)
|
|
{
|
|
di << "Shows information about pave blocks. Use: boppb [#e]\n";
|
|
return 1;
|
|
}
|
|
//
|
|
BOPDS_PDS pDS = BOPTest_Objects::PDS();
|
|
if (!pDS)
|
|
{
|
|
di << " prepare PaveFiller first\n";
|
|
return 1;
|
|
}
|
|
//
|
|
Standard_Boolean bHasPaveBlocks;
|
|
Standard_Integer ind, i1, i2;
|
|
TopAbs_ShapeEnum aType;
|
|
BOPDS_ListIteratorOfListOfPaveBlock aItPB;
|
|
//
|
|
i1 = 0;
|
|
i2 = pDS->NbSourceShapes();
|
|
if (n == 2)
|
|
{
|
|
ind = Draw::Atoi(a[1]);
|
|
i1 = ind;
|
|
i2 = ind + 1;
|
|
}
|
|
//
|
|
for (ind = i1; ind < i2; ++ind)
|
|
{
|
|
const BOPDS_ShapeInfo& aSI = pDS->ShapeInfo(ind);
|
|
aType = aSI.ShapeType();
|
|
if (aType != TopAbs_EDGE)
|
|
{
|
|
continue;
|
|
}
|
|
//
|
|
bHasPaveBlocks = pDS->HasPaveBlocks(ind);
|
|
if (!bHasPaveBlocks)
|
|
{
|
|
continue;
|
|
}
|
|
//
|
|
const BOPDS_ListOfPaveBlock& aLPB = pDS->PaveBlocks(ind);
|
|
aItPB.Initialize(aLPB);
|
|
for (; aItPB.More(); aItPB.Next())
|
|
{
|
|
const Handle(BOPDS_PaveBlock)& aPB = aItPB.Value();
|
|
aPB->Dump();
|
|
printf("\n");
|
|
}
|
|
}
|
|
//
|
|
return 0;
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
Standard_Integer bopcb(Draw_Interpretor& di, Standard_Integer n, const char** a)
|
|
{
|
|
if (n > 2)
|
|
{
|
|
di << "Shows information about common blocks. Use: bopcb [#e]\n";
|
|
return 1;
|
|
}
|
|
//
|
|
BOPDS_PDS pDS = BOPTest_Objects::PDS();
|
|
if (!pDS)
|
|
{
|
|
di << " prepare PaveFiller first\n";
|
|
return 1;
|
|
}
|
|
//
|
|
Standard_Boolean bHasPaveBlocks;
|
|
Standard_Integer ind, i1, i2;
|
|
TopAbs_ShapeEnum aType;
|
|
BOPDS_ListIteratorOfListOfPaveBlock aItPB;
|
|
BOPDS_MapOfCommonBlock aMCB;
|
|
//
|
|
i1 = 0;
|
|
i2 = pDS->NbSourceShapes();
|
|
if (n == 2)
|
|
{
|
|
ind = Draw::Atoi(a[1]);
|
|
i1 = ind;
|
|
i2 = ind + 1;
|
|
}
|
|
//
|
|
for (ind = i1; ind < i2; ++ind)
|
|
{
|
|
const BOPDS_ShapeInfo& aSI = pDS->ShapeInfo(ind);
|
|
aType = aSI.ShapeType();
|
|
if (aType != TopAbs_EDGE)
|
|
{
|
|
continue;
|
|
}
|
|
//
|
|
bHasPaveBlocks = pDS->HasPaveBlocks(ind);
|
|
if (!bHasPaveBlocks)
|
|
{
|
|
continue;
|
|
}
|
|
//
|
|
const BOPDS_ListOfPaveBlock& aLPB = pDS->PaveBlocks(ind);
|
|
aItPB.Initialize(aLPB);
|
|
for (; aItPB.More(); aItPB.Next())
|
|
{
|
|
const Handle(BOPDS_PaveBlock)& aPB = aItPB.Value();
|
|
if (pDS->IsCommonBlock(aPB))
|
|
{
|
|
const Handle(BOPDS_CommonBlock)& aCB = pDS->CommonBlock(aPB);
|
|
if (aMCB.Add(aCB))
|
|
{
|
|
aCB->Dump();
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//
|
|
return 0;
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
Standard_Integer bopsp(Draw_Interpretor& di, Standard_Integer n, const char** a)
|
|
{
|
|
if (n > 2)
|
|
{
|
|
di << "Shows the splits of edges. Use: bopsp [#e]\n";
|
|
return 1;
|
|
}
|
|
//
|
|
BOPDS_PDS pDS = BOPTest_Objects::PDS();
|
|
if (!pDS)
|
|
{
|
|
di << " prepare PaveFiller first\n";
|
|
return 1;
|
|
}
|
|
//
|
|
char buf[32];
|
|
Standard_Boolean bHasPaveBlocks;
|
|
Standard_Integer ind, i1, i2, nSp;
|
|
TopAbs_ShapeEnum aType;
|
|
BOPDS_ListIteratorOfListOfPaveBlock aItPB;
|
|
Standard_CString aText;
|
|
Draw_Color aTextColor(Draw_cyan);
|
|
Handle(BOPTest_DrawableShape) aDShape;
|
|
//
|
|
i1 = 0;
|
|
i2 = pDS->NbSourceShapes();
|
|
if (n == 2)
|
|
{
|
|
ind = Draw::Atoi(a[1]);
|
|
i1 = ind;
|
|
i2 = ind + 1;
|
|
}
|
|
//
|
|
for (ind = i1; ind < i2; ++ind)
|
|
{
|
|
const BOPDS_ShapeInfo& aSI = pDS->ShapeInfo(ind);
|
|
aType = aSI.ShapeType();
|
|
if (aType != TopAbs_EDGE)
|
|
{
|
|
continue;
|
|
}
|
|
//
|
|
bHasPaveBlocks = pDS->HasPaveBlocks(ind);
|
|
if (!bHasPaveBlocks)
|
|
{
|
|
continue;
|
|
}
|
|
//
|
|
di << "Edge " << ind << ": ";
|
|
//
|
|
const BOPDS_ListOfPaveBlock& aLPB = pDS->PaveBlocks(ind);
|
|
aItPB.Initialize(aLPB);
|
|
for (; aItPB.More(); aItPB.Next())
|
|
{
|
|
const Handle(BOPDS_PaveBlock)& aPB = aItPB.Value();
|
|
nSp = aPB->Edge();
|
|
const TopoDS_Shape& aSp = pDS->Shape(nSp);
|
|
//
|
|
Sprintf(buf, "z%d_%d", ind, nSp);
|
|
aText = buf;
|
|
aDShape = new BOPTest_DrawableShape(aSp, aText, aTextColor);
|
|
Draw::Set(aText, aDShape);
|
|
di << buf << " ";
|
|
}
|
|
di << "\n";
|
|
}
|
|
//
|
|
return 0;
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
Standard_Integer bopfon(Draw_Interpretor& di, Standard_Integer n, const char** a)
|
|
{
|
|
return bopfinfo(di, n, a, 0);
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
Standard_Integer bopfin(Draw_Interpretor& di, Standard_Integer n, const char** a)
|
|
{
|
|
return bopfinfo(di, n, a, 1);
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
Standard_Integer bopfsc(Draw_Interpretor& di, Standard_Integer n, const char** a)
|
|
{
|
|
return bopfinfo(di, n, a, 2);
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
Standard_Integer bopfinfo(Draw_Interpretor& di,
|
|
Standard_Integer n,
|
|
const char** a,
|
|
const Standard_Integer iPriz)
|
|
{
|
|
if (n != 2)
|
|
{
|
|
di << "Shows " << ((iPriz == 0) ? "ON" : ((iPriz == 1) ? "IN" : "SC"))
|
|
<< " information for the face. Use: bopf* #f\n";
|
|
return 1;
|
|
}
|
|
//
|
|
BOPDS_PDS pDS = BOPTest_Objects::PDS();
|
|
if (!pDS)
|
|
{
|
|
di << " prepare PaveFiller first\n";
|
|
return 1;
|
|
}
|
|
//
|
|
char aText[32];
|
|
Standard_Integer nF, i1, i2, nV, i, aNb;
|
|
Handle(BOPDS_PaveBlock) aPB;
|
|
//
|
|
nF = Draw::Atoi(a[1]);
|
|
i1 = 0;
|
|
i2 = pDS->NbSourceShapes();
|
|
if (nF < i1 || nF > i2)
|
|
{
|
|
di << " DS does not contain the shape\n";
|
|
return 1;
|
|
}
|
|
//
|
|
if (pDS->ShapeInfo(nF).ShapeType() != TopAbs_FACE)
|
|
{
|
|
di << " The shape is not a face\n";
|
|
return 1;
|
|
}
|
|
//
|
|
if (!pDS->HasFaceInfo(nF))
|
|
{
|
|
di << " The face has no face information\n";
|
|
return 0;
|
|
}
|
|
//
|
|
BOPDS_FaceInfo& aFI = pDS->ChangeFaceInfo(nF);
|
|
//
|
|
BOPDS_IndexedMapOfPaveBlock aMPB;
|
|
TColStd_MapOfInteger aMI;
|
|
if (iPriz == 0)
|
|
{
|
|
strcpy(aText, "On");
|
|
aMPB = aFI.ChangePaveBlocksOn();
|
|
aMI = aFI.ChangeVerticesOn();
|
|
}
|
|
else if (iPriz == 1)
|
|
{
|
|
strcpy(aText, "In");
|
|
aMPB = aFI.ChangePaveBlocksIn();
|
|
aMI = aFI.ChangeVerticesIn();
|
|
}
|
|
else if (iPriz == 2)
|
|
{
|
|
strcpy(aText, "Sc");
|
|
aMPB = aFI.ChangePaveBlocksSc();
|
|
aMI = aFI.ChangeVerticesSc();
|
|
}
|
|
//
|
|
if (aMPB.Extent())
|
|
{
|
|
printf(" pave blocks %s:\n", aText);
|
|
aNb = aMPB.Extent();
|
|
for (i = 1; i <= aNb; ++i)
|
|
{
|
|
aPB = aMPB(i);
|
|
aPB->Dump();
|
|
printf(" \n");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
printf(" no pave blocks %s found\n", aText);
|
|
}
|
|
//
|
|
if (aMI.Extent())
|
|
{
|
|
printf(" vertices %s:\n", aText);
|
|
TColStd_MapIteratorOfMapOfInteger aItMI(aMI);
|
|
for (; aItMI.More(); aItMI.Next())
|
|
{
|
|
nV = aItMI.Value();
|
|
printf(" %d", nV);
|
|
}
|
|
printf(" \n");
|
|
}
|
|
else
|
|
{
|
|
printf(" no verts %s found\n", aText);
|
|
}
|
|
//
|
|
return 0;
|
|
}
|
|
|
|
//=======================================================================
|
|
// function : bopfav
|
|
// purpose : alone vertices on face
|
|
//=======================================================================
|
|
Standard_Integer bopfav(Draw_Interpretor& di, Standard_Integer n, const char** a)
|
|
{
|
|
if (n != 2)
|
|
{
|
|
di << "Shows information about alone vertices for the face. Use: bopfav #f\n";
|
|
return 1;
|
|
}
|
|
//
|
|
BOPDS_PDS pDS = BOPTest_Objects::PDS();
|
|
if (!pDS)
|
|
{
|
|
di << " prepare PaveFiller first\n";
|
|
return 0;
|
|
}
|
|
//
|
|
Standard_Integer i1, i2, nF, nV;
|
|
//
|
|
nF = Draw::Atoi(a[1]);
|
|
i1 = 0;
|
|
i2 = pDS->NbSourceShapes();
|
|
if (nF < i1 || nF > i2)
|
|
{
|
|
di << "DS does not contain the shape\n";
|
|
return 1;
|
|
}
|
|
//
|
|
if (pDS->ShapeInfo(nF).ShapeType() != TopAbs_FACE)
|
|
{
|
|
di << " The shape is not a face\n";
|
|
return 1;
|
|
}
|
|
//
|
|
if (!pDS->HasFaceInfo(nF))
|
|
{
|
|
di << " The face has no face information\n";
|
|
return 0;
|
|
}
|
|
//
|
|
TColStd_ListOfInteger aLI;
|
|
pDS->AloneVertices(nF, aLI);
|
|
if (!aLI.Extent())
|
|
{
|
|
di << " no alone vertices found\n";
|
|
return 0;
|
|
}
|
|
//
|
|
di << " alone vertices: \n";
|
|
TColStd_ListIteratorOfListOfInteger aItLI(aLI);
|
|
for (; aItLI.More(); aItLI.Next())
|
|
{
|
|
nV = aItLI.Value();
|
|
di << nV << " ";
|
|
}
|
|
di << "\n";
|
|
//
|
|
return 0;
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
Standard_Integer bopimage(Draw_Interpretor& di, Standard_Integer n, const char** a)
|
|
{
|
|
if (n != 2)
|
|
{
|
|
di << "Shows split parts of the shape. Use: bopimage s\n";
|
|
return 1;
|
|
}
|
|
//
|
|
BOPDS_PDS pDS = BOPTest_Objects::PDS();
|
|
if (!pDS)
|
|
{
|
|
di << " prepare PaveFiller first\n";
|
|
return 1;
|
|
}
|
|
//
|
|
TopoDS_Shape aS = DBRep::Get(a[1]);
|
|
if (aS.IsNull())
|
|
{
|
|
di << a[1] << " is a null shape\n";
|
|
return 1;
|
|
}
|
|
//
|
|
BOPAlgo_Builder& aBuilder = BOPTest_Objects::Builder();
|
|
const TopTools_DataMapOfShapeListOfShape& anImages = aBuilder.Images();
|
|
if (!anImages.IsBound(aS))
|
|
{
|
|
di << " no images found\n";
|
|
return 0;
|
|
}
|
|
//
|
|
char buf[32];
|
|
Standard_Integer i;
|
|
BRep_Builder aBB;
|
|
TopoDS_Compound aC;
|
|
//
|
|
aBB.MakeCompound(aC);
|
|
//
|
|
const TopTools_ListOfShape& aLSIm = anImages.Find(aS);
|
|
TopTools_ListIteratorOfListOfShape aIt(aLSIm);
|
|
for (i = 0; aIt.More(); aIt.Next(), ++i)
|
|
{
|
|
const TopoDS_Shape& aSIm = aIt.Value();
|
|
aBB.Add(aC, aSIm);
|
|
}
|
|
//
|
|
di << i << " images found\n";
|
|
sprintf(buf, "%s_im", a[1]);
|
|
DBRep::Set(buf, aC);
|
|
di << buf << "\n";
|
|
//
|
|
return 0;
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
Standard_Integer boporigin(Draw_Interpretor& di, Standard_Integer n, const char** a)
|
|
{
|
|
if (n != 2)
|
|
{
|
|
di << "Shows the original shape for the shape. Use: boporigin s\n";
|
|
return 1;
|
|
}
|
|
//
|
|
BOPDS_PDS pDS = BOPTest_Objects::PDS();
|
|
if (!pDS)
|
|
{
|
|
di << " prepare PaveFiller first\n";
|
|
return 1;
|
|
}
|
|
//
|
|
TopoDS_Shape aS = DBRep::Get(a[1]);
|
|
if (aS.IsNull())
|
|
{
|
|
di << a[1] << " is a null shape\n";
|
|
return 0;
|
|
}
|
|
//
|
|
BOPAlgo_Builder& aBuilder = BOPTest_Objects::Builder();
|
|
const TopTools_DataMapOfShapeListOfShape& aDMI = aBuilder.Origins();
|
|
if (!aDMI.IsBound(aS))
|
|
{
|
|
di << " no origins found\n";
|
|
return 0;
|
|
}
|
|
//
|
|
char buf[32];
|
|
sprintf(buf, "%s_or", a[1]);
|
|
//
|
|
const TopTools_ListOfShape& aLSx = aDMI.Find(aS);
|
|
if (aLSx.Extent() == 1)
|
|
{
|
|
DBRep::Set(buf, aLSx.First());
|
|
di << "1 origin found\n" << buf << "\n";
|
|
return 0;
|
|
}
|
|
//
|
|
TopoDS_Compound aCOr;
|
|
BRep_Builder().MakeCompound(aCOr);
|
|
//
|
|
TopTools_ListIteratorOfListOfShape aItLSx(aLSx);
|
|
for (; aItLSx.More(); aItLSx.Next())
|
|
{
|
|
BRep_Builder().Add(aCOr, aItLSx.Value());
|
|
}
|
|
//
|
|
DBRep::Set(buf, aCOr);
|
|
//
|
|
di << aLSx.Extent() << " origins found\n";
|
|
di << buf << "\n";
|
|
//
|
|
return 0;
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
Standard_Integer bopfsd(Draw_Interpretor& di, Standard_Integer n, const char** a)
|
|
{
|
|
if (n != 2)
|
|
{
|
|
di << "Shows SD faces for the face: Use: bopfsd f\n";
|
|
return 1;
|
|
}
|
|
//
|
|
BOPDS_PDS pDS = BOPTest_Objects::PDS();
|
|
if (!pDS)
|
|
{
|
|
di << " prepare PaveFiller first\n";
|
|
return 1;
|
|
}
|
|
//
|
|
TopoDS_Shape aS = DBRep::Get(a[1]);
|
|
if (aS.IsNull())
|
|
{
|
|
di << a[1] << " is a null shape\n";
|
|
return 1;
|
|
}
|
|
//
|
|
BOPAlgo_Builder& aBuilder = BOPTest_Objects::Builder();
|
|
const TopTools_DataMapOfShapeShape& aDMSD = aBuilder.ShapesSD();
|
|
if (!aDMSD.IsBound(aS))
|
|
{
|
|
di << " shape has no sd shape\n";
|
|
return 0;
|
|
}
|
|
//
|
|
char buf[32];
|
|
Standard_Integer i;
|
|
BRep_Builder aBB;
|
|
TopoDS_Compound aC;
|
|
//
|
|
aBB.MakeCompound(aC);
|
|
//
|
|
TopTools_DataMapIteratorOfDataMapOfShapeShape aItSD;
|
|
aItSD.Initialize(aDMSD);
|
|
for (i = 0; aItSD.More(); aItSD.Next())
|
|
{
|
|
const TopoDS_Shape& aSK = aItSD.Key();
|
|
const TopoDS_Shape& aSV = aItSD.Value();
|
|
if (aSK.IsEqual(aS))
|
|
{
|
|
if (!aSV.IsEqual(aS))
|
|
{
|
|
aBB.Add(aC, aS);
|
|
++i;
|
|
}
|
|
}
|
|
//
|
|
else if (aSV.IsEqual(aS))
|
|
{
|
|
if (!aSK.IsEqual(aS))
|
|
{
|
|
aBB.Add(aC, aS);
|
|
++i;
|
|
}
|
|
}
|
|
}
|
|
//
|
|
di << i << " SD shapes found\n";
|
|
//
|
|
sprintf(buf, "%s_sd", a[1]);
|
|
DBRep::Set(buf, aC);
|
|
//
|
|
di << buf << "\n";
|
|
return 0;
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
Standard_Integer bopbface(Draw_Interpretor& di, Standard_Integer n, const char** a)
|
|
{
|
|
if (n != 3)
|
|
{
|
|
di << "Build faces from surface and set of shared edges. Use: bopbface fr cx\n";
|
|
return 1;
|
|
}
|
|
//
|
|
TopoDS_Shape aS = DBRep::Get(a[2]);
|
|
if (aS.IsNull())
|
|
{
|
|
di << a[1] << " is a null shape\n";
|
|
return 1;
|
|
}
|
|
//
|
|
TopoDS_Face aF;
|
|
TopTools_ListOfShape aLE;
|
|
Standard_Integer i;
|
|
//
|
|
TopoDS_Iterator aItS(aS);
|
|
for (i = 0; aItS.More(); aItS.Next(), ++i)
|
|
{
|
|
const TopoDS_Shape& aSx = aItS.Value();
|
|
if (!i)
|
|
{
|
|
if (aSx.ShapeType() != TopAbs_FACE)
|
|
{
|
|
di << " shape " << i << " is not a face\n";
|
|
return 1;
|
|
}
|
|
aF = *(TopoDS_Face*)&aSx;
|
|
}
|
|
else
|
|
{
|
|
if (aSx.ShapeType() != TopAbs_EDGE)
|
|
{
|
|
di << " shape " << i << " is not an edge\n";
|
|
return 1;
|
|
}
|
|
aLE.Append(aSx);
|
|
}
|
|
}
|
|
//
|
|
BOPAlgo_BuilderFace aBF;
|
|
aBF.SetFace(aF);
|
|
aBF.SetShapes(aLE);
|
|
aBF.Perform();
|
|
BOPTest::ReportAlerts(aBF.GetReport());
|
|
if (aBF.HasErrors())
|
|
{
|
|
return 0;
|
|
}
|
|
//
|
|
char buf[128];
|
|
const TopTools_ListOfShape& aLFR = aBF.Areas();
|
|
TopTools_ListIteratorOfListOfShape aIt(aLFR);
|
|
for (i = 1; aIt.More(); aIt.Next(), ++i)
|
|
{
|
|
const TopoDS_Shape& aFR = aIt.Value();
|
|
sprintf(buf, "%s_%d", a[1], i);
|
|
DBRep::Set(buf, aFR);
|
|
di << " " << buf;
|
|
}
|
|
//
|
|
i = aLFR.Extent();
|
|
if (i)
|
|
{
|
|
di << "\n " << i << " faces were built\n";
|
|
}
|
|
else
|
|
{
|
|
di << " No faces were built\n";
|
|
}
|
|
//
|
|
return 0;
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
Standard_Integer bopbsolid(Draw_Interpretor& di, Standard_Integer n, const char** a)
|
|
{
|
|
if (n != 3)
|
|
{
|
|
di << "Build solids from set of shared faces. Use: bopbsolid sr cx\n";
|
|
return 1;
|
|
}
|
|
//
|
|
TopoDS_Shape aS = DBRep::Get(a[2]);
|
|
if (aS.IsNull())
|
|
{
|
|
di << a[1] << " is a null shape\n";
|
|
return 1;
|
|
}
|
|
//
|
|
TopTools_ListOfShape aLF;
|
|
TopExp_Explorer aExp(aS, TopAbs_FACE);
|
|
for (; aExp.More(); aExp.Next())
|
|
{
|
|
const TopoDS_Shape& aF = aExp.Current();
|
|
aLF.Append(aF);
|
|
}
|
|
//
|
|
if (aLF.IsEmpty())
|
|
{
|
|
di << " No faces to build solids\n";
|
|
return 1;
|
|
}
|
|
//
|
|
BOPAlgo_BuilderSolid aBS;
|
|
aBS.SetShapes(aLF);
|
|
aBS.Perform();
|
|
BOPTest::ReportAlerts(aBS.GetReport());
|
|
if (aBS.HasErrors())
|
|
{
|
|
return 0;
|
|
}
|
|
//
|
|
Standard_Integer i;
|
|
TopoDS_Compound aSolids;
|
|
BRep_Builder aBB;
|
|
//
|
|
aBB.MakeCompound(aSolids);
|
|
//
|
|
char buf[128];
|
|
const TopTools_ListOfShape& aLSR = aBS.Areas();
|
|
TopTools_ListIteratorOfListOfShape aIt(aLSR);
|
|
for (i = 1; aIt.More(); aIt.Next(), ++i)
|
|
{
|
|
const TopoDS_Shape& aSR = aIt.Value();
|
|
sprintf(buf, "%s_%d", a[1], i);
|
|
DBRep::Set(buf, aSR);
|
|
di << " " << buf;
|
|
}
|
|
//
|
|
i = aLSR.Extent();
|
|
if (i)
|
|
{
|
|
di << "\n " << i << " solids were built\n";
|
|
}
|
|
else
|
|
{
|
|
di << " No solids were built\n";
|
|
}
|
|
//
|
|
return 0;
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
void GetTypeByName(const char* theName, TopAbs_ShapeEnum& theType)
|
|
{
|
|
if (!strcmp(theName, "v") || !strcmp(theName, "V"))
|
|
{
|
|
theType = TopAbs_VERTEX;
|
|
}
|
|
else if (!strcmp(theName, "e") || !strcmp(theName, "E"))
|
|
{
|
|
theType = TopAbs_EDGE;
|
|
}
|
|
else if (!strcmp(theName, "w") || !strcmp(theName, "W"))
|
|
{
|
|
theType = TopAbs_WIRE;
|
|
}
|
|
else if (!strcmp(theName, "f") || !strcmp(theName, "F"))
|
|
{
|
|
theType = TopAbs_FACE;
|
|
}
|
|
else if (!strcmp(theName, "sh") || !strcmp(theName, "Sh") || !strcmp(theName, "SH"))
|
|
{
|
|
theType = TopAbs_SHELL;
|
|
}
|
|
else if (!strcmp(theName, "s") || !strcmp(theName, "S"))
|
|
{
|
|
theType = TopAbs_SOLID;
|
|
}
|
|
else if (!strcmp(theName, "cs") || !strcmp(theName, "Cs") || !strcmp(theName, "CS"))
|
|
{
|
|
theType = TopAbs_COMPSOLID;
|
|
}
|
|
else if (!strcmp(theName, "c") || !strcmp(theName, "C"))
|
|
{
|
|
theType = TopAbs_COMPOUND;
|
|
}
|
|
else
|
|
{
|
|
theType = TopAbs_SHAPE;
|
|
}
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
void GetNameByType(const TopAbs_ShapeEnum& theType, char* theName)
|
|
{
|
|
switch (theType)
|
|
{
|
|
case TopAbs_VERTEX:
|
|
strcpy(theName, "V");
|
|
break;
|
|
case TopAbs_EDGE:
|
|
strcpy(theName, "E");
|
|
break;
|
|
case TopAbs_WIRE:
|
|
strcpy(theName, "w");
|
|
break;
|
|
case TopAbs_FACE:
|
|
strcpy(theName, "F");
|
|
break;
|
|
case TopAbs_SHELL:
|
|
strcpy(theName, "Sh");
|
|
break;
|
|
case TopAbs_SOLID:
|
|
strcpy(theName, "S");
|
|
break;
|
|
case TopAbs_COMPSOLID:
|
|
strcpy(theName, "Cs");
|
|
break;
|
|
case TopAbs_COMPOUND:
|
|
strcpy(theName, "c");
|
|
break;
|
|
default:
|
|
strcpy(theName, "Shape");
|
|
break;
|
|
}
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
template <class InterfType>
|
|
void DumpInterfs(const NCollection_Vector<InterfType>& theVInterf, Draw_Interpretor& di)
|
|
{
|
|
Standard_Integer i, aNb, n1, n2, nNew;
|
|
char buf[64];
|
|
//
|
|
aNb = theVInterf.Length();
|
|
if (aNb == 0)
|
|
{
|
|
di << "Not found\n";
|
|
return;
|
|
}
|
|
//
|
|
di << aNb << " interference(s) found\n";
|
|
for (i = 0; i < aNb; ++i)
|
|
{
|
|
const InterfType& anInt = theVInterf(i);
|
|
anInt.Indices(n1, n2);
|
|
if (anInt.HasIndexNew())
|
|
{
|
|
nNew = anInt.IndexNew();
|
|
Sprintf(buf, " (%d, %d, %d)\n", n1, n2, nNew);
|
|
}
|
|
else
|
|
{
|
|
Sprintf(buf, " (%d, %d)\n", n1, n2);
|
|
}
|
|
di << buf;
|
|
}
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
template <class InterfType>
|
|
void SearchNewIndex(const char* theCType,
|
|
const Standard_Integer theInd,
|
|
const NCollection_Vector<InterfType>& theVInterf,
|
|
Draw_Interpretor& di)
|
|
{
|
|
char buf[64];
|
|
Standard_Boolean bFound;
|
|
Standard_Integer i, aNb, n1, n2, nNew;
|
|
//
|
|
bFound = Standard_False;
|
|
aNb = theVInterf.Length();
|
|
for (i = 0; i < aNb; ++i)
|
|
{
|
|
const InterfType& anInt = theVInterf(i);
|
|
nNew = anInt.IndexNew();
|
|
if (theInd == nNew)
|
|
{
|
|
if (!bFound)
|
|
{
|
|
di << theCType;
|
|
bFound = Standard_True;
|
|
}
|
|
//
|
|
anInt.Indices(n1, n2);
|
|
sprintf(buf, "(%d, %d) ", n1, n2);
|
|
di << buf;
|
|
}
|
|
}
|
|
if (bFound)
|
|
{
|
|
di << "\n";
|
|
}
|
|
}
|