mirror of
https://github.com/Open-Cascade-SAS/OCCT.git
synced 2026-09-01 15:57:56 +08:00
Pasukhin Dmitry
1a2e039ab9
Some *trace* old debug classes existed for long time. Their purpose is accumulte some trace logic for TopOpe or BRepFeat packages. The problem is that that functionality is no longer used by active developers. And the functionality in some cases changes behavior and make more complicated to debug. Lack of documentation how to work with and impact on behavior and usage of global/static variables make these classes heavy legacy.
3093 lines
81 KiB
C++
3093 lines
81 KiB
C++
// Created on: 1996-03-07
|
|
// Created by: Jean Yves LEBEY
|
|
// Copyright (c) 1996-1999 Matra Datavision
|
|
// Copyright (c) 1999-2014 OPEN CASCADE SAS
|
|
//
|
|
// This file is part of Open CASCADE Technology software library.
|
|
//
|
|
// This library is free software; you can redistribute it and/or modify it under
|
|
// the terms of the GNU Lesser General Public License version 2.1 as published
|
|
// by the Free Software Foundation, with special exception defined in the file
|
|
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
|
|
// distribution for complete text of the license and disclaimer of any warranty.
|
|
//
|
|
// Alternatively, this file may be used under the terms of Open CASCADE
|
|
// commercial license or contractual agreement.
|
|
|
|
#include <BRep_Tool.hxx>
|
|
#include <BRepLProp_SLProps.hxx>
|
|
#include <BRepLProp_SurfaceTool.hxx>
|
|
#include <GeomAbs_SurfaceType.hxx>
|
|
#include <Precision.hxx>
|
|
#include <TopoDS.hxx>
|
|
#include <TopoDS_Shape.hxx>
|
|
#include <TopOpeBRepBuild_BuilderON.hxx>
|
|
#include <TopOpeBRepBuild_define.hxx>
|
|
#include <TopOpeBRepDS_connex.hxx>
|
|
#include <TopOpeBRepDS_Interference.hxx>
|
|
#include <TopOpeBRepDS_ProcessInterferencesTool.hxx>
|
|
#include <TopOpeBRepDS_ShapeShapeInterference.hxx>
|
|
#include <TopOpeBRepTool_GEOMETRY.hxx>
|
|
#include <TopOpeBRepTool_PROJECT.hxx>
|
|
#include <TopOpeBRepTool_TOPOLOGY.hxx>
|
|
#include <TopOpeBRepTool_SC.hxx>
|
|
#include <TopOpeBRepTool_TOOL.hxx>
|
|
|
|
#ifdef OCCT_DEBUG
|
|
|
|
Standard_EXPORT void debON(const int iF)
|
|
{
|
|
std::cout << "++ debON " << iF << " " << std::endl;
|
|
}
|
|
|
|
Standard_EXPORT void debON(const int iF, const TopAbs_State TB1, const TopAbs_State TB2)
|
|
{
|
|
std::cout << "++ debON " << iF << " :TB1=";
|
|
TopAbs::Print(TB1, std::cout);
|
|
std::cout << ",TB2=";
|
|
TopAbs::Print(TB2, std::cout);
|
|
std::cout << std::endl;
|
|
}
|
|
|
|
Standard_EXPORT void debfillonf(const int iF)
|
|
{
|
|
std::cout << "++ debfillonf " << iF << " " << std::endl;
|
|
}
|
|
|
|
Standard_EXPORT void debfillone(const int iE)
|
|
{
|
|
std::cout << "++ debfillone " << iE << " " << std::endl;
|
|
}
|
|
|
|
Standard_EXPORT void debfillonfe() {}
|
|
|
|
Standard_EXPORT void debfillonfemess(const int f, const int e)
|
|
{
|
|
std::cout << "++ debfillonfe f" << f << " e" << e << std::endl;
|
|
debfillonfe();
|
|
}
|
|
|
|
Standard_EXPORT void debfillonfe3d() {}
|
|
|
|
Standard_EXPORT void debfillonfemess3d(const int f, const int e)
|
|
{
|
|
std::cout << "++ debfillonfe3d f" << f << " e" << e << std::endl;
|
|
debfillonfe3d();
|
|
}
|
|
|
|
Standard_EXPORT void debfillonfemess(const int iFOR,
|
|
const int iEG,
|
|
TopOpeBRepBuild_Builder* const& PB,
|
|
TopOpeBRepBuild_WireEdgeSet* const& PWES,
|
|
const TCollection_AsciiString& str)
|
|
{
|
|
PB->GdumpSHASTA(iEG, TopAbs_ON, *PWES, str);
|
|
debfillonfemess(iFOR, iEG);
|
|
}
|
|
|
|
Standard_EXPORT void debaddpwes(const int iFOR,
|
|
const TopAbs_State TB1,
|
|
const int iEG,
|
|
const TopAbs_Orientation neworiE,
|
|
TopOpeBRepBuild_Builder* const& PB,
|
|
TopOpeBRepBuild_WireEdgeSet* const& PWES,
|
|
const TCollection_AsciiString& str1,
|
|
const TCollection_AsciiString& str2)
|
|
{
|
|
PB->GdumpSHASTA(iFOR, TB1, *PWES, str1, str2);
|
|
std::cout << iEG << " : 1 edge ";
|
|
TopAbs::Print(neworiE, std::cout);
|
|
std::cout << std::endl;
|
|
}
|
|
|
|
Standard_EXPORT bool DEBTEFOR(const TopOpeBRepBuild_Builder& B, const int iFOR, const int GI)
|
|
{
|
|
return B.GtraceSPS(iFOR, GI);
|
|
}
|
|
#endif
|
|
|
|
#ifdef OCCT_DEBUG
|
|
Standard_EXPORT void FUN_RaiseON()
|
|
{
|
|
throw Standard_Failure("BuilderON");
|
|
}
|
|
|
|
static void FUN_cout(const TopoDS_Shape& eON)
|
|
{
|
|
TopAbs_Orientation oE = eON.Orientation();
|
|
if (oE == TopAbs_FORWARD)
|
|
std::cout << "-> + eONF" << std::endl;
|
|
if (oE == TopAbs_REVERSED)
|
|
std::cout << "-> + eONR" << std::endl;
|
|
if (oE == TopAbs_INTERNAL)
|
|
std::cout << "-> + eONI" << std::endl;
|
|
if (oE == TopAbs_EXTERNAL)
|
|
std::cout << "-> + eONE" << std::endl;
|
|
}
|
|
#endif
|
|
|
|
#define M_FORWARD(st) (st == TopAbs_FORWARD)
|
|
#define M_REVERSED(st) (st == TopAbs_REVERSED)
|
|
#define M_INTERNAL(st) (st == TopAbs_INTERNAL)
|
|
#define M_EXTERNAL(st) (st == TopAbs_EXTERNAL)
|
|
|
|
// NYI : TopOpeBRepTool_ShapeTool::ShapesSameOriented -> CurvesSameOriented NYI for E !line
|
|
// Standard_IMPORT bool TopOpeBRepBuild_FUN_aresamegeom(const TopoDS_Shape& S1,const
|
|
// TopoDS_Shape& S2);
|
|
|
|
//=================================================================================================
|
|
|
|
TopOpeBRepBuild_BuilderON::TopOpeBRepBuild_BuilderON() = default;
|
|
|
|
//=================================================================================================
|
|
|
|
TopOpeBRepBuild_BuilderON::TopOpeBRepBuild_BuilderON(
|
|
TopOpeBRepBuild_Builder* const& PB,
|
|
const TopoDS_Shape& FOR,
|
|
TopOpeBRepBuild_GTopo* const& PG,
|
|
NCollection_List<TopoDS_Shape>* const& PLSclass,
|
|
TopOpeBRepBuild_WireEdgeSet* const& PWES)
|
|
{
|
|
Perform(PB, FOR, PG, PLSclass, PWES);
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
void TopOpeBRepBuild_BuilderON::Perform(TopOpeBRepBuild_Builder* const& PB,
|
|
const TopoDS_Shape& FOR,
|
|
TopOpeBRepBuild_GTopo* const& PG,
|
|
NCollection_List<TopoDS_Shape>* const& PLSclass,
|
|
TopOpeBRepBuild_WireEdgeSet* const& PWES)
|
|
{
|
|
myPB = PB;
|
|
myFace = FOR;
|
|
myPG = PG;
|
|
myPLSclass = PLSclass;
|
|
myPWES = PWES;
|
|
|
|
#ifdef OCCT_DEBUG
|
|
int iFOR;
|
|
bool tFOR = myPB->GtraceSPS(FOR, iFOR);
|
|
if (tFOR)
|
|
debfillonf(iFOR);
|
|
#endif
|
|
|
|
const TopOpeBRepDS_DataStructure& BDS = myPB->DataStructure()->DS();
|
|
const NCollection_List<occ::handle<TopOpeBRepDS_Interference>>& LI =
|
|
BDS.ShapeInterferences(myFace);
|
|
for (NCollection_List<occ::handle<TopOpeBRepDS_Interference>>::Iterator ILI(LI); ILI.More();
|
|
ILI.Next())
|
|
{
|
|
const occ::handle<TopOpeBRepDS_Interference>& I = ILI.Value();
|
|
GFillONPartsWES1(I);
|
|
}
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
bool TopOpeBRepBuild_BuilderON::GFillONCheckI(const occ::handle<TopOpeBRepDS_Interference>& I) const
|
|
{
|
|
const TopOpeBRepDS_DataStructure& BDS = myPB->DataStructure()->DS();
|
|
|
|
occ::handle<TopOpeBRepDS_ShapeShapeInterference> SSI =
|
|
occ::down_cast<TopOpeBRepDS_ShapeShapeInterference>(I);
|
|
if (SSI.IsNull())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
TopOpeBRepDS_Kind GT, ST;
|
|
int GI, SI;
|
|
FDS_data(SSI, GT, GI, ST, SI);
|
|
if (GT != TopOpeBRepDS_EDGE || ST != TopOpeBRepDS_FACE)
|
|
{
|
|
return false;
|
|
}
|
|
#ifdef OCCT_DEBUG
|
|
// int iFOR=BDS.Shape(myFace);
|
|
#endif
|
|
const TopoDS_Edge& EG = TopoDS::Edge(BDS.Shape(GI, false));
|
|
#ifdef OCCT_DEBUG
|
|
// int iEG=BDS.Shape(EG, false);
|
|
#endif
|
|
const TopoDS_Shape& FS = BDS.Shape(SI, false);
|
|
#ifdef OCCT_DEBUG
|
|
// int iFS=BDS.Shape(FS, false);
|
|
#endif
|
|
TopAbs_ShapeEnum ShapeInterf = TopAbs_FACE;
|
|
const TopOpeBRepDS_Transition& TFE = SSI->Transition();
|
|
TopAbs_ShapeEnum shab = TFE.ShapeBefore(), shaa = TFE.ShapeAfter();
|
|
if (shaa != ShapeInterf || shab != ShapeInterf)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool isrest = BDS.IsSectionEdge(EG);
|
|
bool issplit = myPB->IsSplit(EG, TopAbs_ON);
|
|
bool keep = (isrest && issplit);
|
|
if (!keep)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const NCollection_List<TopoDS_Shape>& lEspON = myPB->Splits(EG, TopAbs_ON);
|
|
if (lEspON.Extent() == 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
#ifdef OCCT_DEBUG
|
|
// const TopoDS_Shape& EspON=lEspON.First();
|
|
#endif
|
|
int rankFS = myPB->GShapeRank(FS);
|
|
int rankFOR = myPB->GShapeRank(myFace);
|
|
return rankFS != 0 && rankFOR != 0;
|
|
} // GFillONCheckI
|
|
|
|
//=================================================================================================
|
|
|
|
void TopOpeBRepBuild_BuilderON::GFillONPartsWES1(const occ::handle<TopOpeBRepDS_Interference>& I)
|
|
{
|
|
const TopOpeBRepDS_DataStructure& BDS = myPB->DataStructure()->DS();
|
|
#ifdef OCCT_DEBUG
|
|
int iFOR =
|
|
#endif
|
|
BDS.Shape(myFace);
|
|
TopOpeBRepDS_Kind GT, ST;
|
|
int GI, SI;
|
|
FDS_data(I, GT, GI, ST, SI);
|
|
|
|
bool Iok = GFillONCheckI(I);
|
|
if (!Iok)
|
|
{
|
|
return;
|
|
}
|
|
|
|
const TopoDS_Edge& EG = TopoDS::Edge(BDS.Shape(GI));
|
|
// const TopoDS_Shape& FS=BDS.Shape(SI);
|
|
#ifdef OCCT_DEBUG
|
|
// int iEG=BDS.Shape(EG);
|
|
// int iFS=BDS.Shape(FS);
|
|
#endif
|
|
|
|
#ifdef OCCT_DEBUG
|
|
bool tEFOR = DEBTEFOR(*myPB, iFOR, GI);
|
|
if (tEFOR)
|
|
debfillonfemess(iFOR, GI, myPB, myPWES, "--- GFillONPartsWES1");
|
|
#endif
|
|
|
|
const NCollection_List<TopoDS_Shape>& lEspON = myPB->Splits(EG, TopAbs_ON);
|
|
#ifdef OCCT_DEBUG
|
|
// int nEspON=lEspON.Extent();
|
|
#endif
|
|
for (NCollection_List<TopoDS_Shape>::Iterator it(lEspON); it.More(); it.Next())
|
|
{
|
|
const TopoDS_Shape& EspON = it.Value();
|
|
GFillONPartsWES2(I, EspON);
|
|
}
|
|
} // GFillONPartsWES1
|
|
|
|
#ifdef OCCT_DEBUG
|
|
Standard_EXPORT void FUN_coutmess(const TCollection_AsciiString& m)
|
|
{
|
|
std::cout << m;
|
|
}
|
|
#else
|
|
Standard_EXPORT void FUN_coutmess(const TCollection_AsciiString&) {}
|
|
#endif
|
|
|
|
//------------------------------------------------------
|
|
#ifdef OCCT_DEBUG
|
|
bool FUN_keepEON(const TopOpeBRepBuild_Builder& B,
|
|
#else
|
|
bool FUN_keepEON(const TopOpeBRepBuild_Builder&,
|
|
#endif
|
|
const TopoDS_Shape& sEG,
|
|
const TopoDS_Shape& sFOR,
|
|
const TopoDS_Shape& sFS,
|
|
#ifdef OCCT_DEBUG
|
|
const bool EGBoundFOR,
|
|
#else
|
|
const bool,
|
|
#endif
|
|
const TopOpeBRepDS_Transition& TFE,
|
|
const TopAbs_State TB1,
|
|
const TopAbs_State)
|
|
//------------------------------------------------------
|
|
{
|
|
// on construit l'etat TB1 de FOR par rapport a FS.
|
|
// sur face FOR,on transitionne (TFE) en l'arete EG par rapport a la face FS.
|
|
// TFE est defini sur la geometrie naturelle de la face orientee FOR,
|
|
// c'est a dire sur FF=FOR orientee FORWARD,par rapport a la matiere
|
|
// definie par la face orientee FS.
|
|
// on cherche oEGFF=orientation de EG dans FF
|
|
TopoDS_Edge EG = TopoDS::Edge(sEG);
|
|
TopoDS_Face FF = TopoDS::Face(sFOR);
|
|
FF.Orientation(TopAbs_FORWARD);
|
|
TopoDS_Face FS = TopoDS::Face(sFS);
|
|
|
|
#ifdef OCCT_DEBUG
|
|
int iEG; /*bool tEG=*/
|
|
B.GtraceSPS(EG, iEG);
|
|
int iFF; /*bool tFF=*/
|
|
B.GtraceSPS(FF, iFF);
|
|
int iFS; /*bool tFS=*/
|
|
B.GtraceSPS(FS, iFS);
|
|
bool tFFEG = DEBTEFOR(B, iFF, iEG);
|
|
if (tFFEG)
|
|
debfillonfemess(iFF, iEG);
|
|
bool tFSEG = DEBTEFOR(B, iFS, iEG);
|
|
if (tFSEG)
|
|
debfillonfemess(iFS, iEG);
|
|
#endif
|
|
|
|
#ifdef OCCT_DEBUG
|
|
bool keep1 = true;
|
|
bool keep2 = true;
|
|
#endif
|
|
bool keep3 = true;
|
|
bool isclosedFF = BRep_Tool::IsClosed(EG, FF);
|
|
if (isclosedFF)
|
|
{
|
|
#ifdef OCCT_DEBUG
|
|
keep1 = true;
|
|
keep2 = true;
|
|
#endif
|
|
keep3 = true;
|
|
}
|
|
else
|
|
{
|
|
TopAbs_Orientation oEGFF = TopAbs_FORWARD;
|
|
FUN_tool_orientEinF(EG, FF, oEGFF);
|
|
|
|
#ifdef OCCT_DEBUG
|
|
TopAbs_Orientation omatFS1 = TFE.Orientation(TB1);
|
|
if (oEGFF == TopAbs_REVERSED)
|
|
omatFS1 = TopAbs::Complement(omatFS1);
|
|
keep1 = (omatFS1 == TopAbs_FORWARD);
|
|
|
|
TopAbs_Orientation omatFS2 = TFE.Orientation(TB1);
|
|
keep2 = (omatFS2 == oEGFF);
|
|
#endif
|
|
|
|
TopAbs_State tfeb = TFE.Before();
|
|
TopAbs_State tfea = TFE.After();
|
|
if (oEGFF == TopAbs_FORWARD)
|
|
{
|
|
keep3 = (tfea == TB1);
|
|
}
|
|
else if (oEGFF == TopAbs_REVERSED)
|
|
{
|
|
keep3 = (tfeb == TB1);
|
|
}
|
|
else if (oEGFF == TopAbs_EXTERNAL)
|
|
{
|
|
keep3 = (tfea == TB1 || tfeb == TB1);
|
|
}
|
|
else if (oEGFF == TopAbs_INTERNAL)
|
|
{
|
|
keep3 = (tfea == TB1 || tfeb == TB1);
|
|
}
|
|
}
|
|
|
|
#ifdef OCCT_DEBUG
|
|
if (tFFEG || tFSEG)
|
|
{
|
|
if (keep1 != keep2 || keep1 != keep3 || keep2 != keep3)
|
|
{
|
|
std::cout << "\nkeepEON : EGB " << EGBoundFOR << " EG " << iEG << " FOR " << iFF << " FS "
|
|
<< iFS;
|
|
std::cout << " keep1 " << keep1 << " keep2 " << keep2 << " keep3 " << keep3;
|
|
std::cout << " !=!=!=!=!=!=!=!=!=!=!=!=!=!=!=";
|
|
std::cout << std::endl;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
return keep3;
|
|
}
|
|
|
|
Standard_EXPORT TopAbs_State FUN_build_TB(TopOpeBRepBuild_Builder* const& PB, const int rank)
|
|
{
|
|
bool opeFus = PB->Opefus();
|
|
bool opec12 = PB->Opec12();
|
|
bool opec21 = PB->Opec21();
|
|
bool opeCom = PB->Opecom();
|
|
TopAbs_State sta = TopAbs_UNKNOWN;
|
|
if (opeFus)
|
|
{
|
|
sta = TopAbs_OUT;
|
|
}
|
|
if (opeCom)
|
|
{
|
|
sta = TopAbs_IN;
|
|
}
|
|
if (opec12)
|
|
{
|
|
sta = (rank == 1) ? TopAbs_OUT : TopAbs_IN;
|
|
}
|
|
if (opec21)
|
|
{
|
|
sta = (rank == 2) ? TopAbs_OUT : TopAbs_IN;
|
|
}
|
|
return sta;
|
|
}
|
|
|
|
static bool FUN_Kpart0(const GeomAbs_SurfaceType& ST1, const GeomAbs_SurfaceType& ST2)
|
|
{
|
|
bool plane1 = (ST1 == GeomAbs_Plane);
|
|
bool cyli1 = (ST1 == GeomAbs_Cylinder);
|
|
bool cone1 = (ST1 == GeomAbs_Cone);
|
|
|
|
bool cyli2 = (ST2 == GeomAbs_Cylinder);
|
|
bool cone2 = (ST2 == GeomAbs_Cone);
|
|
bool sphe2 = (ST2 == GeomAbs_Sphere);
|
|
bool quad2 = cyli2 || cone2 || sphe2 || (ST2 == GeomAbs_Torus);
|
|
|
|
if (plane1 && quad2)
|
|
{
|
|
return true;
|
|
}
|
|
if (cyli1 && sphe2)
|
|
{
|
|
return true;
|
|
}
|
|
if (cone1 && sphe2)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static int FUN_Kpart(const GeomAbs_SurfaceType& ST1, const GeomAbs_SurfaceType& ST2)
|
|
{
|
|
bool kpart0 = FUN_Kpart0(ST1, ST2);
|
|
if (kpart0)
|
|
{
|
|
return 1;
|
|
}
|
|
kpart0 = FUN_Kpart0(ST2, ST1);
|
|
if (kpart0)
|
|
{
|
|
return 2;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int FUN_findeSD(const TopOpeBRepDS_DataStructure& BDS,
|
|
const TopoDS_Edge& EspON,
|
|
const TopoDS_Edge& EG,
|
|
const TopoDS_Face& FOR,
|
|
TopAbs_Orientation& oeSD,
|
|
const int D)
|
|
{
|
|
// chercher eSD = SameDomain3d/2d de EG, arete de FOR, qui contient EspON
|
|
gp_Pnt ptON;
|
|
double parON;
|
|
FUN_tool_findPinE(EspON, ptON, parON);
|
|
NCollection_List<TopoDS_Shape> lesdSD;
|
|
if (D == 3)
|
|
{
|
|
FDS_HasSameDomain3d(BDS, EG, &lesdSD);
|
|
}
|
|
if (D == 2)
|
|
{
|
|
FDS_HasSameDomain2d(BDS, EG, &lesdSD);
|
|
}
|
|
for (NCollection_List<TopoDS_Shape>::Iterator it(lesdSD); it.More(); it.Next())
|
|
{
|
|
TopoDS_Edge eSD = TopoDS::Edge(it.Value());
|
|
TopAbs_Orientation oesd;
|
|
bool eSDofFOR = FUN_tool_orientEinFFORWARD(eSD, FOR, oesd);
|
|
if (!eSDofFOR)
|
|
{
|
|
continue;
|
|
}
|
|
TopAbs_State staeSD = FUN_tool_staPinE(ptON, eSD);
|
|
if (staeSD == TopAbs_IN)
|
|
{
|
|
int i = BDS.Shape(eSD);
|
|
oeSD = oesd;
|
|
return i;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static bool ComputeFaceCrvtInSec(const TopoDS_Face& aFace,
|
|
const gp_Pnt2d& aP2d,
|
|
const gp_Dir& aSecDir,
|
|
double& aCrvt)
|
|
{
|
|
BRepAdaptor_Surface aSurf(aFace);
|
|
int cn = BRepLProp_SurfaceTool::Continuity(aSurf);
|
|
if (cn < 2)
|
|
{
|
|
return false;
|
|
}
|
|
BRepLProp_SLProps aProp(aSurf, aP2d.X(), aP2d.Y(), 2, Precision::Confusion());
|
|
if (!aProp.IsCurvatureDefined())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (aProp.IsUmbilic())
|
|
{
|
|
aCrvt = aProp.MaxCurvature();
|
|
return true;
|
|
}
|
|
|
|
double maxCrv = aProp.MaxCurvature();
|
|
double minCrv = aProp.MinCurvature();
|
|
gp_Dir maxDir, minDir;
|
|
aProp.CurvatureDirections(maxDir, minDir);
|
|
double cosMax = aSecDir * maxDir;
|
|
double cosMin = aSecDir * minDir;
|
|
aCrvt = maxCrv * cosMax + minCrv * cosMin;
|
|
return true;
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
void TopOpeBRepBuild_BuilderON::GFillONPartsWES2(const occ::handle<TopOpeBRepDS_Interference>& I,
|
|
const TopoDS_Shape& EspON)
|
|
{
|
|
const occ::handle<TopOpeBRepDS_HDataStructure>& HDS = myPB->DataStructure();
|
|
const TopOpeBRepDS_DataStructure& BDS = HDS->DS();
|
|
occ::handle<TopOpeBRepDS_ShapeShapeInterference> SSI(
|
|
occ::down_cast<TopOpeBRepDS_ShapeShapeInterference>(I));
|
|
TopAbs_State TB1, TB2;
|
|
myPG->StatesON(TB1, TB2);
|
|
TopAbs_State TB = TB1;
|
|
TopOpeBRepDS_Kind GT, ST;
|
|
int GI, SI;
|
|
FDS_data(SSI, GT, GI, ST, SI);
|
|
const TopOpeBRepDS_Transition& TFE = SSI->Transition();
|
|
bool EGBoundFOR = SSI->GBound();
|
|
const TopoDS_Face& FOR = TopoDS::Face(myFace);
|
|
int iFOR = BDS.Shape(FOR);
|
|
const TopoDS_Edge& eON = TopoDS::Edge(EspON);
|
|
const TopoDS_Edge& EG = TopoDS::Edge(BDS.Shape(GI));
|
|
#ifdef OCCT_DEBUG
|
|
int iEG =
|
|
#endif
|
|
BDS.Shape(EG);
|
|
const TopoDS_Face& FS = TopoDS::Face(BDS.Shape(SI));
|
|
int iFS = BDS.Shape(FS);
|
|
|
|
double tola = Precision::Angular() * 1.e3; // nyitol
|
|
|
|
TopAbs_Orientation oFOR = BDS.Shape(iFOR).Orientation();
|
|
TopAbs_Orientation oFS = BDS.Shape(iFS).Orientation();
|
|
|
|
// clang-format off
|
|
bool isclosedFF=FUN_tool_IsClosingE(EG,FOR,FOR); //xpu240898 : cto900J5 faulty yapc2(FOR17,FS18,EG15)
|
|
// clang-format on
|
|
bool isclosedFS = FUN_tool_IsClosingE(EG, FS, FS); // xpu240898
|
|
bool isclosed = (isclosedFF || isclosedFS);
|
|
bool isrest = BDS.IsSectionEdge(EG);
|
|
#ifdef OCCT_DEBUG
|
|
// bool issplit=myPB->IsSplit(EG,TopAbs_ON);
|
|
#endif
|
|
int rankFS = myPB->GShapeRank(FS);
|
|
int rankEG = myPB->GShapeRank(EG);
|
|
int rankFOR = myPB->GShapeRank(FOR);
|
|
TopAbs_Orientation OTFE = TFE.Orientation(TopAbs_IN);
|
|
TopAbs_State TFEbef = TFE.Before();
|
|
TopAbs_State TFEaft = TFE.After();
|
|
#ifdef OCCT_DEBUG
|
|
// bool EGboundFOR =
|
|
// occ::down_cast<TopOpeBRepDS_ShapeShapeInterference>(I)->GBound();
|
|
#endif
|
|
bool eghassd = HDS->HasSameDomain(EG);
|
|
NCollection_List<TopoDS_Shape> le3;
|
|
bool eghassd3d = FDS_HasSameDomain3d(BDS, EG, &le3);
|
|
int ie3d = 0;
|
|
TopAbs_Orientation oe3d = TopAbs_EXTERNAL;
|
|
int ie2d = 0;
|
|
TopAbs_Orientation oe2d = TopAbs_EXTERNAL;
|
|
NCollection_List<TopoDS_Shape> lfcx;
|
|
FDSCNX_FaceEdgeConnexFaces(FS, EG, HDS, lfcx);
|
|
int nlfcx = lfcx.Extent();
|
|
|
|
bool hsdFOR = HDS->HasSameDomain(FOR);
|
|
TopOpeBRepDS_Config cFOR = TopOpeBRepDS_UNSHGEOMETRY;
|
|
int irefFOR = 0;
|
|
TopAbs_Orientation orefFOR = TopAbs_EXTERNAL;
|
|
bool FORisref = false;
|
|
if (hsdFOR)
|
|
{
|
|
cFOR = BDS.SameDomainOri(iFOR);
|
|
if (hsdFOR)
|
|
{
|
|
irefFOR = BDS.SameDomainRef(FOR);
|
|
}
|
|
if (irefFOR != 0)
|
|
{
|
|
orefFOR = BDS.Shape(irefFOR).Orientation();
|
|
}
|
|
FORisref = (irefFOR == iFOR);
|
|
}
|
|
|
|
bool opeFus = myPB->Opefus();
|
|
bool opec12 = myPB->Opec12();
|
|
#ifdef OCCT_DEBUG
|
|
// bool opec21 = myPB->Opec21();
|
|
#endif
|
|
bool opeCut = myPB->Opec12() || myPB->Opec21();
|
|
bool opeCom = myPB->Opecom();
|
|
// clang-format off
|
|
bool ComOfCut = opeCut && (TB1 == TB2) && (TB1 == TopAbs_IN); //xpu200598 only if FFSDSO
|
|
// clang-format on
|
|
|
|
TopAbs_State TBFOR = FUN_build_TB(myPB, rankFOR);
|
|
|
|
#ifdef OCCT_DEBUG
|
|
bool tFOR = myPB->GtraceSPS(iFOR);
|
|
bool tE = myPB->GtraceSPS(GI);
|
|
bool tEFOR = DEBTEFOR(*myPB, iFOR, GI);
|
|
if (tFOR)
|
|
debON(iFOR);
|
|
#endif
|
|
|
|
double factor = 1.e2;
|
|
double tolEG = BRep_Tool::Tolerance(EG) * factor; // NYITOLXPU
|
|
double tolFOR = BRep_Tool::Tolerance(FOR) * factor; // NYITOLXPU
|
|
double tolFS = BRep_Tool::Tolerance(FS) * factor; // NYITOLXPU
|
|
|
|
double f, l;
|
|
FUN_tool_bounds(eON, f, l);
|
|
double x = 0.456189;
|
|
double parON = (1 - x) * f + x * l;
|
|
|
|
// xpu150698 : spON(EG)=spON1+spON2+.., spON1 ON EsdEG, spON2 shares no
|
|
// geometry with any other edge.
|
|
// FRA11018 (FOR=f5,EG=e18,EsdEG=e7)
|
|
bool espONesd = false;
|
|
int Iesd = 0; // xpu150698
|
|
if (eghassd)
|
|
{
|
|
espONesd = FUN_ds_ONesd(BDS, GI, EspON, Iesd); // xpu150698
|
|
}
|
|
bool eONsoEsd = false;
|
|
if (eghassd && (Iesd != 0))
|
|
{
|
|
const TopoDS_Edge& Esd = TopoDS::Edge(BDS.Shape(Iesd));
|
|
bool ok = FUN_tool_curvesSO(eON, Esd, eONsoEsd);
|
|
if (!ok)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
bool eONFS = true; // xpu240898
|
|
if (eghassd && (!espONesd))
|
|
{
|
|
gp_Pnt pON;
|
|
bool ok = FUN_tool_value(parON, eON, pON);
|
|
if (!ok)
|
|
{
|
|
return;
|
|
}
|
|
gp_Pnt2d uvFS;
|
|
double d = 1.;
|
|
ok = FUN_tool_projPonboundedF(pON, FS, uvFS, d);
|
|
if (!ok)
|
|
{
|
|
return;
|
|
}
|
|
double tolF = FUN_tool_maxtol(FS);
|
|
eONFS = (d < tolF);
|
|
}
|
|
// ------------------------------------
|
|
bool eghassdON = eghassd && espONesd;
|
|
bool eghassd3dON = eghassd3d && espONesd;
|
|
// ------------------------------------
|
|
|
|
bool yap00 = true; // xpu180998 : cto900Q2
|
|
yap00 = yap00 && (!isclosed);
|
|
yap00 = yap00 && (EGBoundFOR);
|
|
yap00 = yap00 && (espONesd);
|
|
yap00 = yap00 && (!hsdFOR); // xpu280998 : PRO14892 (FOR16,FS30,GI20)
|
|
if (yap00)
|
|
{
|
|
const NCollection_List<occ::handle<TopOpeBRepDS_Interference>>& lI =
|
|
BDS.ShapeInterferences(FOR);
|
|
NCollection_List<occ::handle<TopOpeBRepDS_Interference>> lIcopy;
|
|
FDS_assign(lI, lIcopy);
|
|
NCollection_List<occ::handle<TopOpeBRepDS_Interference>> lIGesd;
|
|
int nGesd = FUN_selectGIinterference(lIcopy, Iesd, lIGesd);
|
|
if (nGesd != 0)
|
|
{
|
|
yap00 = false; // ES has interference on G=edge(Iesd)
|
|
}
|
|
}
|
|
|
|
bool yap0 = true;
|
|
yap0 = yap0 && (!isclosed);
|
|
yap0 = yap0 && (EGBoundFOR);
|
|
yap0 = yap0 && (!eghassd);
|
|
|
|
bool yap0bis = true; // xpu160698
|
|
yap0bis = yap0bis && (!isclosed);
|
|
yap0bis = yap0bis && (EGBoundFOR);
|
|
yap0bis = yap0bis && (eghassd); // xpu300798 : cto 902 B7
|
|
yap0bis = yap0bis && (!eghassdON);
|
|
yap0bis = yap0bis && eONFS; // xpu240898 : cto900J3 (e7on_2 NOT ON FS, FOR18,FS17,EG7)
|
|
yap0bis = yap0bis && !ComOfCut; // xpu270798 : boxes240798, f14in,GI=34
|
|
if (yap0bis)
|
|
{
|
|
yap0 = true;
|
|
}
|
|
|
|
bool hassd3dON = false;
|
|
// if (isclosed && !EGBoundFOR && eghassd3d) { -xpu110898 -> yapc3
|
|
if (!EGBoundFOR && eghassd3d)
|
|
{
|
|
ie3d = ::FUN_findeSD(BDS, eON, EG, FOR, oe3d, 3);
|
|
hassd3dON = (ie3d != 0);
|
|
}
|
|
|
|
bool yapc1 = true;
|
|
yapc1 = yapc1 && (isclosed);
|
|
yapc1 = yapc1 && (!EGBoundFOR);
|
|
yapc1 = yapc1 && (eghassd3d);
|
|
yapc1 = yapc1 && hassd3dON; // xpu230798
|
|
|
|
bool yapc2a = true;
|
|
yapc2a = yapc2a && (isclosed);
|
|
yapc2a = yapc2a && (!eghassd3d);
|
|
|
|
// xpu240798 cto902A3 (iFOR=5,GI=3,iFCX=6) : complement yapc1
|
|
bool yapc2b = true;
|
|
yapc2b = yapc2b && (isclosed);
|
|
yapc2b = yapc2b && (!EGBoundFOR);
|
|
yapc2b = yapc2b && (eghassd3d);
|
|
yapc2b = yapc2b && (!hassd3dON);
|
|
|
|
bool yapc2c = true;
|
|
yapc2c = yapc2c && (isclosed);
|
|
yapc2c = yapc2c && (EGBoundFOR);
|
|
yapc2c = yapc2c && (eghassd3d);
|
|
|
|
bool yapc2 = yapc2a;
|
|
yapc2 = yapc2 || yapc2b || yapc2c; // xpu240798
|
|
|
|
bool yapc3 = true;
|
|
yapc3 = yapc3 && (!isclosed);
|
|
yapc3 = yapc3 && (eghassd3d);
|
|
yapc3 = yapc3 && (hassd3dON);
|
|
bool e3closedFOR = false;
|
|
if (hassd3dON)
|
|
{
|
|
const TopoDS_Edge& e3d = TopoDS::Edge(BDS.Shape(ie3d));
|
|
e3closedFOR = BRep_Tool::IsClosed(e3d, FOR);
|
|
}
|
|
yapc3 = yapc3 && e3closedFOR; // => !EGBoundFOR
|
|
|
|
//=========================================
|
|
if (yap00)
|
|
{
|
|
#ifdef OCCT_DEBUG
|
|
if (tEFOR)
|
|
debfillonfemess(iFOR, iEG, myPB, myPWES, "yap0 GFillON");
|
|
if (tE)
|
|
{
|
|
std::cout << "yap00(FOR" << iFOR << " FS" << iFS << " EG" << GI << ") ";
|
|
std::cout << "TB1=";
|
|
TopAbs::Print(TB1, std::cout);
|
|
std::cout << " TB2=";
|
|
TopAbs::Print(TB2, std::cout);
|
|
std::cout << std::endl;
|
|
}
|
|
#endif
|
|
|
|
TopAbs_Orientation oeff;
|
|
FUN_tool_orientEinFFORWARD(EG, FOR, oeff);
|
|
bool add = false;
|
|
if (oeff == TopAbs_FORWARD)
|
|
{
|
|
add = (TFEaft == TB);
|
|
}
|
|
else if (oeff == TopAbs_REVERSED)
|
|
{
|
|
add = (TFEbef == TB);
|
|
}
|
|
else if (oeff == TopAbs_INTERNAL)
|
|
{
|
|
add = true;
|
|
}
|
|
else if (oeff == TopAbs_EXTERNAL)
|
|
{
|
|
add = true;
|
|
}
|
|
if (!add)
|
|
{
|
|
return;
|
|
}
|
|
|
|
const TopoDS_Shape& Esd = BDS.Shape(Iesd);
|
|
bool isONFS = false;
|
|
TopExp_Explorer ex(FS, TopAbs_EDGE);
|
|
for (; ex.More(); ex.Next())
|
|
{
|
|
if (ex.Current().IsSame(Esd))
|
|
{
|
|
isONFS = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!isONFS)
|
|
{
|
|
return;
|
|
}
|
|
|
|
double parEG;
|
|
bool ok = FUN_tool_parE(eON, parON, EG, parEG, tolEG);
|
|
if (!ok)
|
|
{
|
|
return;
|
|
}
|
|
bool samegeom;
|
|
ok = FUN_tool_curvesSO(EG, parEG, eON, samegeom);
|
|
if (!ok)
|
|
{
|
|
return;
|
|
}
|
|
TopAbs_Orientation neworiE = oeff;
|
|
if (!samegeom && (M_FORWARD(neworiE) || M_REVERSED(neworiE)))
|
|
{
|
|
neworiE = TopAbs::Complement(neworiE);
|
|
}
|
|
|
|
TopoDS_Shape newE = EspON;
|
|
newE.Orientation(neworiE);
|
|
#ifdef OCCT_DEBUG
|
|
if (tEFOR)
|
|
debaddpwes(iFOR, TB1, iEG, neworiE, myPB, myPWES, "yap00 GFillON", "WES+ EspON ");
|
|
if (tE)
|
|
FUN_cout(newE);
|
|
#endif
|
|
myPWES->AddStartElement(newE);
|
|
return;
|
|
}
|
|
|
|
//=========================================
|
|
if (yap0)
|
|
{
|
|
#ifdef OCCT_DEBUG
|
|
if (tEFOR)
|
|
debfillonfemess(iFOR, iEG, myPB, myPWES, "yap0 GFillON");
|
|
if (tE)
|
|
{
|
|
std::cout << "yap0(FOR" << iFOR << " FS" << iFS << " EG" << GI << ") ";
|
|
std::cout << "TB1=";
|
|
TopAbs::Print(TB1, std::cout);
|
|
std::cout << " TB2=";
|
|
TopAbs::Print(TB2, std::cout);
|
|
std::cout << std::endl;
|
|
}
|
|
#endif
|
|
|
|
TopAbs_Orientation oeff;
|
|
FUN_tool_orientEinFFORWARD(EG, FOR, oeff);
|
|
bool add = false;
|
|
if (oeff == TopAbs_FORWARD)
|
|
{
|
|
add = (TFEaft == TB);
|
|
}
|
|
else if (oeff == TopAbs_REVERSED)
|
|
{
|
|
add = (TFEbef == TB);
|
|
}
|
|
else if (oeff == TopAbs_INTERNAL)
|
|
{
|
|
add = true;
|
|
}
|
|
else if (oeff == TopAbs_EXTERNAL)
|
|
{
|
|
add = true;
|
|
}
|
|
if (!add)
|
|
{
|
|
return; // xpu100698
|
|
}
|
|
|
|
// parEG :
|
|
double parEG;
|
|
bool ok = FUN_tool_parE(eON, parON, EG, parEG, tolEG);
|
|
if (!ok)
|
|
{
|
|
return;
|
|
}
|
|
// ngFS, ngFOR, xxFOR :
|
|
double tolON = std::max(tolFS, tolEG);
|
|
tolON *= 1.e2; //*****CAREFUL***** : xpu040998, cto 904 A3
|
|
gp_Vec ngFS;
|
|
ok = FUN_tool_nggeomF(parEG, EG, FS, ngFS, tolON);
|
|
if (!ok)
|
|
{
|
|
return;
|
|
}
|
|
tolON = std::max(tolFOR, tolEG);
|
|
tolON *= 1.e2; //*****CAREFUL***** : xpu040998, cto 904 A3
|
|
gp_Vec ngFOR;
|
|
ok = FUN_tool_nggeomF(parEG, EG, FOR, ngFOR, tolON);
|
|
if (!ok)
|
|
{
|
|
return;
|
|
}
|
|
gp_Dir xxFOR;
|
|
ok = FUN_tool_getxx(FOR, EG, parEG, ngFOR, xxFOR);
|
|
if (!ok)
|
|
{
|
|
return;
|
|
}
|
|
// ntFS, ntFOR, ntdot :
|
|
gp_Dir ntFS(ngFS);
|
|
if (M_REVERSED(oFS))
|
|
{
|
|
ntFS.Reverse();
|
|
}
|
|
gp_Dir ntFOR(ngFOR);
|
|
if (M_REVERSED(oFOR))
|
|
{
|
|
ntFOR.Reverse();
|
|
}
|
|
double ntdot = ntFOR.Dot(ntFS);
|
|
|
|
// xpu180698 : Kpart=FOR tangent to FS at EG
|
|
bool Kpart = (OTFE == TopAbs_EXTERNAL) || (OTFE == TopAbs_INTERNAL);
|
|
if (Kpart)
|
|
{
|
|
bool Ktg = (std::abs(1 - std::abs(ntdot)) < tola * 1.e2);
|
|
Kpart = Ktg;
|
|
}
|
|
if (Kpart)
|
|
{
|
|
gp_Pnt2d UVfor, UVfs;
|
|
ok = FUN_tool_paronEF(EG, parEG, FOR, UVfor, tolFOR);
|
|
if (!ok)
|
|
{
|
|
return;
|
|
}
|
|
gp_Pnt Pfor, Pfs;
|
|
FUN_tool_value(UVfor, FOR, Pfor);
|
|
tolON = std::max(std::max(tolFOR, tolFS), tolEG) * 10.;
|
|
double d;
|
|
|
|
BRepAdaptor_Surface BSfor(FOR);
|
|
GeomAbs_SurfaceType STfor = BSfor.GetType();
|
|
BRepAdaptor_Surface BSfs(FS);
|
|
GeomAbs_SurfaceType STfs = BSfs.GetType();
|
|
int kpart = FUN_Kpart(STfor, STfs);
|
|
if (kpart == 0)
|
|
{
|
|
// MSV: general case, such as BSpline or Bezier surface or two cylinders.
|
|
// We should detect if FOR and FS have different curvature in section
|
|
// by plane perpendicular to EG at point parEG.
|
|
double crvFOR, crvFS;
|
|
if (!ComputeFaceCrvtInSec(FOR, UVfor, xxFOR, crvFOR))
|
|
{
|
|
return;
|
|
}
|
|
if (!FUN_tool_projPonF(Pfor, FS, UVfs, d))
|
|
{
|
|
return;
|
|
}
|
|
if (!ComputeFaceCrvtInSec(FS, UVfs, xxFOR, crvFS))
|
|
{
|
|
return;
|
|
}
|
|
if (M_REVERSED(oFOR))
|
|
{
|
|
crvFOR = -crvFOR;
|
|
}
|
|
if (M_REVERSED(oFS))
|
|
{
|
|
crvFS = -crvFS;
|
|
}
|
|
if (ntdot < 0.)
|
|
{
|
|
crvFS = -crvFS;
|
|
}
|
|
double eps = Precision::Confusion();
|
|
double absCrvFOR = std::abs(crvFOR), absCrvFS = std::abs(crvFS);
|
|
if (absCrvFOR <= eps && absCrvFS <= eps)
|
|
{
|
|
return;
|
|
}
|
|
if (absCrvFOR > eps && absCrvFS > eps)
|
|
{
|
|
double tolR = tolON;
|
|
double rcrvFOR = 1. / crvFOR, rcrvFS = 1. / crvFS;
|
|
if (std::abs(rcrvFOR - rcrvFS) <= tolR)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
// if we are here the curvatures are different
|
|
}
|
|
// SO :
|
|
bool SO = (ntdot > 0.);
|
|
// Pfor :
|
|
Pfor.Translate(xxFOR.XYZ() * tolON * 10.);
|
|
ok = FUN_tool_projPonF(Pfor, FOR, UVfor, d);
|
|
if (!ok)
|
|
{
|
|
return;
|
|
}
|
|
FUN_tool_value(UVfor, FOR, Pfor);
|
|
// Pfs :
|
|
ok = FUN_tool_projPonF(Pfor, FS, UVfs, d);
|
|
if (!ok)
|
|
{
|
|
return;
|
|
}
|
|
FUN_tool_value(UVfs, FS, Pfs);
|
|
// Dforfs :
|
|
gp_Dir Dforfs(gp_Vec(Pfor, Pfs));
|
|
|
|
bool keep = true;
|
|
double dot = Dforfs.Dot(ntFOR); // xpu250698
|
|
if (SO)
|
|
{
|
|
bool so2and3 = (dot > 0); // xpu250698
|
|
bool so2 = so2and3; // xpu250698
|
|
|
|
if (opeFus)
|
|
{
|
|
keep = !so2;
|
|
}
|
|
if (opeCom)
|
|
{
|
|
keep = so2;
|
|
}
|
|
if (opeCut)
|
|
{
|
|
if (TBFOR == TopAbs_OUT)
|
|
{
|
|
keep = !so2;
|
|
}
|
|
else
|
|
{
|
|
keep = so2;
|
|
}
|
|
}
|
|
} // SO
|
|
else
|
|
{
|
|
bool do1and2 = (dot > 0); // xpu250698
|
|
bool do1 = do1and2; // xpu250698
|
|
|
|
if (opeFus)
|
|
{
|
|
keep = do1;
|
|
}
|
|
if (opeCom)
|
|
{
|
|
keep = !do1;
|
|
}
|
|
if (opeCut)
|
|
{
|
|
if (TBFOR == TopAbs_OUT)
|
|
{
|
|
keep = do1;
|
|
}
|
|
else
|
|
{
|
|
keep = !do1;
|
|
}
|
|
}
|
|
} // !SO
|
|
if (!keep)
|
|
{
|
|
return;
|
|
}
|
|
} // Kpart
|
|
else
|
|
{
|
|
// dot :
|
|
double dot = ntFS.Dot(xxFOR);
|
|
bool positive = (dot > 0);
|
|
|
|
bool keep = true;
|
|
if (opeFus)
|
|
{
|
|
keep = positive;
|
|
}
|
|
if (opeCom)
|
|
{
|
|
keep = !positive;
|
|
}
|
|
if (opeCut)
|
|
{
|
|
if (positive)
|
|
{
|
|
keep = (TBFOR == TopAbs_OUT);
|
|
}
|
|
else
|
|
{
|
|
keep = (TBFOR != TopAbs_OUT);
|
|
}
|
|
}
|
|
if (!keep)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
TopoDS_Face newF = FOR;
|
|
TopoDS_Shape newE = EspON;
|
|
TopAbs_Orientation neworiE;
|
|
FUN_tool_orientEinFFORWARD(EG, newF, neworiE);
|
|
|
|
if (hsdFOR)
|
|
{
|
|
// xpu260698 : cto902A5 : fonds de poche (FOR=f14,GI=e24,refFOR=f13)
|
|
bool reverse = false;
|
|
if (!FORisref)
|
|
{
|
|
// xpu170698 : PRO13555 (FOR=f19,GI=e10,FS=f15)
|
|
bool FORDO = (cFOR == TopOpeBRepDS_DIFFORIENTED);
|
|
if (FORDO)
|
|
{
|
|
reverse = !reverse;
|
|
}
|
|
if (oFOR != orefFOR)
|
|
{
|
|
reverse = !reverse;
|
|
}
|
|
}
|
|
|
|
if (opeFus)
|
|
{ // nyixpu260698
|
|
}
|
|
if (opeCom)
|
|
{ // nyixpu260698
|
|
}
|
|
if (opeCut)
|
|
{
|
|
if (TBFOR == TopAbs_IN)
|
|
{
|
|
// xpu290798 : cto902C1 (FOR19,FS16,GI22) f9ou is DO f19in
|
|
// sp(f9)+sp(f19) are in same WES, e22on is OUT f9 =>
|
|
// do NOT reverse neworiE
|
|
// reverse = true;
|
|
}
|
|
else
|
|
{
|
|
}
|
|
}
|
|
if (reverse)
|
|
{
|
|
neworiE = TopAbs::Complement(neworiE);
|
|
}
|
|
} // hsdFOR
|
|
|
|
newE.Orientation(neworiE);
|
|
#ifdef OCCT_DEBUG
|
|
if (tEFOR)
|
|
debaddpwes(iFOR, TB1, iEG, neworiE, myPB, myPWES, "yap0 GFillON", "WES+ EspON ");
|
|
if (tE)
|
|
FUN_cout(newE);
|
|
#endif
|
|
myPWES->AddStartElement(newE);
|
|
return;
|
|
} // yap0
|
|
|
|
//=========================================
|
|
if (yapc1)
|
|
{
|
|
#ifdef OCCT_DEBUG
|
|
if (tEFOR)
|
|
debfillonfemess(iFOR, iEG, myPB, myPWES, "yapc1 GFillON");
|
|
if (tE)
|
|
{
|
|
std::cout << "yapc1(FOR" << iFOR << " FS" << iFS << " EG" << GI << ") ";
|
|
std::cout << "TB1=";
|
|
TopAbs::Print(TB1, std::cout);
|
|
std::cout << " TB2=";
|
|
TopAbs::Print(TB2, std::cout);
|
|
std::cout << std::endl;
|
|
}
|
|
#endif
|
|
const TopoDS_Edge& e3d = TopoDS::Edge(BDS.Shape(ie3d));
|
|
|
|
// e3d = SameDomain3d de EG, arete de FOR, qui contient EspON
|
|
TopOpeBRepDS_Config cf;
|
|
bool cfok = FDS_Config3d(EspON, e3d, cf);
|
|
if (!cfok)
|
|
{
|
|
return;
|
|
}
|
|
|
|
TopAbs_Orientation oe3dk = oe3d;
|
|
// bool samegeom = ::TopOpeBRepBuild_FUN_aresamegeom(EG,e3d);
|
|
double parEG;
|
|
bool ok = FUN_tool_parE(eON, parON, EG, parEG, tolEG);
|
|
if (!ok)
|
|
{
|
|
return; // nyiRAISE
|
|
}
|
|
bool samegeom;
|
|
ok = FUN_tool_curvesSO(EG, parEG, e3d, samegeom);
|
|
if (!ok)
|
|
{
|
|
return; // nyiRAISE
|
|
}
|
|
if (!samegeom)
|
|
{
|
|
oe3dk = TopAbs::Complement(oe3dk);
|
|
}
|
|
|
|
bool keep3d = false;
|
|
if (oe3dk == TopAbs_FORWARD)
|
|
{
|
|
keep3d = (TFEaft == TB1);
|
|
}
|
|
else if (oe3dk == TopAbs_REVERSED)
|
|
{
|
|
keep3d = (TFEbef == TB1);
|
|
}
|
|
else if (oe3dk == TopAbs_INTERNAL)
|
|
{
|
|
keep3d = true;
|
|
}
|
|
else if (oe3dk == TopAbs_EXTERNAL)
|
|
{
|
|
keep3d = false;
|
|
}
|
|
|
|
#ifdef OCCT_DEBUG
|
|
// if(tEFOR) {std::cout<<std::endl<<"yapc1 keep3d :
|
|
// "<<keep3d<<std::endl;debfillonfemess3d(iFOR,iEG);}
|
|
#endif
|
|
|
|
if (keep3d)
|
|
{
|
|
TopAbs_Orientation neworiE = oe3d;
|
|
if (cf == TopOpeBRepDS_DIFFORIENTED)
|
|
{
|
|
neworiE = TopAbs::Complement(neworiE);
|
|
}
|
|
TopoDS_Shape newE = EspON;
|
|
newE.Orientation(neworiE);
|
|
|
|
#ifdef OCCT_DEBUG
|
|
if (tEFOR)
|
|
debaddpwes(iFOR, TB1, iEG, neworiE, myPB, myPWES, "yapc1 GFillON", "WES+ EspON ");
|
|
if (tE)
|
|
FUN_cout(newE);
|
|
#endif
|
|
myPWES->AddStartElement(newE);
|
|
}
|
|
|
|
return;
|
|
} // yapc1
|
|
|
|
//=========================================
|
|
if (yapc2)
|
|
{
|
|
#ifdef OCCT_DEBUG
|
|
if (tEFOR)
|
|
debfillonfemess(iFOR, iEG, myPB, myPWES, "yapc2 GFillON");
|
|
if (tE)
|
|
{
|
|
std::cout << "yapc2(FOR" << iFOR << " FS" << iFS << " EG" << GI << ") ";
|
|
std::cout << "TB1=";
|
|
TopAbs::Print(TB1, std::cout);
|
|
std::cout << " TB2=";
|
|
TopAbs::Print(TB2, std::cout);
|
|
std::cout << std::endl;
|
|
}
|
|
#endif
|
|
|
|
bool keep = false;
|
|
if (EGBoundFOR)
|
|
{
|
|
keep = FUN_keepEON(*myPB, EG, FOR, FS, EGBoundFOR, TFE, TB1, TB2);
|
|
}
|
|
else
|
|
{
|
|
keep = true;
|
|
}
|
|
if (!keep)
|
|
{
|
|
return;
|
|
}
|
|
|
|
TopAbs_Orientation neworiE = TFE.Orientation(TB1);
|
|
bool giveoEinFOR = EGBoundFOR && (!isclosedFF) && (M_EXTERNAL(neworiE) || M_INTERNAL(neworiE));
|
|
if (giveoEinFOR)
|
|
{
|
|
FUN_tool_orientEinFFORWARD(EG, FOR, neworiE);
|
|
}
|
|
|
|
// xpu230798 : cto902A3 (iFOR=5,GI=3,iFCX=6)
|
|
// (iFOR=20,GI=3,iFCX=6)
|
|
if (yapc2b && (!M_EXTERNAL(neworiE)))
|
|
{
|
|
TopOpeBRepTool_ShapeClassifier& PSC = FSC_GetPSC(FOR);
|
|
TopAbs_State state2d = FSC_StateEonFace(EspON, 0.345, FOR, PSC);
|
|
if (state2d != TopAbs_IN)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
TopoDS_Shape newE = EspON;
|
|
bool addFORREV = false;
|
|
TopAbs_Orientation neworiEk = TopAbs_EXTERNAL;
|
|
if (!isclosedFF)
|
|
{
|
|
neworiEk = neworiE;
|
|
}
|
|
else if (M_FORWARD(neworiE) || M_REVERSED(neworiE))
|
|
{
|
|
neworiEk = neworiE;
|
|
}
|
|
else if (M_INTERNAL(neworiE))
|
|
{
|
|
addFORREV = true;
|
|
}
|
|
newE.Orientation(neworiEk);
|
|
|
|
#ifdef OCCT_DEBUG
|
|
if (tEFOR)
|
|
{
|
|
if (!isclosedFF)
|
|
debaddpwes(iFOR, TB1, iEG, neworiE, myPB, myPWES, "yapc2 GFillON", "WES+ EspON not closed");
|
|
else if (M_FORWARD(neworiE) || M_REVERSED(neworiE))
|
|
debaddpwes(iFOR,
|
|
TB1,
|
|
iEG,
|
|
neworiEk,
|
|
myPB,
|
|
myPWES,
|
|
"yapc2 GFillON closed",
|
|
"WES+ EspON F|R");
|
|
else if (M_INTERNAL(neworiE))
|
|
{
|
|
debaddpwes(iFOR,
|
|
TB1,
|
|
iEG,
|
|
TopAbs_FORWARD,
|
|
myPB,
|
|
myPWES,
|
|
"yapc2 GFillON closed",
|
|
"WES+ EspON INTERNAL");
|
|
debaddpwes(iFOR,
|
|
TB1,
|
|
iEG,
|
|
TopAbs_REVERSED,
|
|
myPB,
|
|
myPWES,
|
|
"yapc2 GFillON closed",
|
|
"WES+ EspON INTERNAL");
|
|
}
|
|
}
|
|
if (tE)
|
|
{
|
|
if (addFORREV)
|
|
{
|
|
newE.Orientation(TopAbs_FORWARD);
|
|
FUN_cout(newE);
|
|
newE.Orientation(TopAbs_REVERSED);
|
|
FUN_cout(newE);
|
|
}
|
|
else
|
|
FUN_cout(newE);
|
|
}
|
|
#endif
|
|
|
|
if (addFORREV)
|
|
{
|
|
newE.Orientation(TopAbs_FORWARD);
|
|
myPWES->AddStartElement(newE);
|
|
|
|
newE.Orientation(TopAbs_REVERSED);
|
|
myPWES->AddStartElement(newE);
|
|
}
|
|
else
|
|
{
|
|
myPWES->AddStartElement(newE);
|
|
}
|
|
return;
|
|
} // yapc2
|
|
|
|
//=========================================
|
|
if (yapc3)
|
|
{
|
|
#ifdef OCCT_DEBUG
|
|
if (tEFOR)
|
|
debfillonfemess(iFOR, iEG, myPB, myPWES, "yapc3 GFillON");
|
|
if (tE)
|
|
{
|
|
std::cout << "yapc3(FOR" << iFOR << " FS" << iFS << " EG" << GI << ") ";
|
|
std::cout << "TB1=";
|
|
TopAbs::Print(TB1, std::cout);
|
|
std::cout << " TB2=";
|
|
TopAbs::Print(TB2, std::cout);
|
|
std::cout << std::endl;
|
|
}
|
|
#endif
|
|
|
|
bool keep = false;
|
|
if (EGBoundFOR)
|
|
{
|
|
keep = FUN_keepEON(*myPB, EG, FOR, FS, EGBoundFOR, TFE, TB1, TB2);
|
|
}
|
|
else
|
|
{
|
|
keep = true;
|
|
}
|
|
if (!keep)
|
|
{
|
|
return;
|
|
}
|
|
|
|
TopAbs_Orientation neworiE = TFE.Orientation(TB1);
|
|
bool giveoEinFOR = EGBoundFOR && !isclosedFF && (M_EXTERNAL(neworiE) || M_INTERNAL(neworiE));
|
|
if (giveoEinFOR)
|
|
{
|
|
FUN_tool_orientEinFFORWARD(EG, FOR, neworiE);
|
|
}
|
|
|
|
TopoDS_Shape newE = EspON;
|
|
bool addFORREV = false;
|
|
TopAbs_Orientation neworiEk = TopAbs_EXTERNAL;
|
|
|
|
// xpu110798 : cto902B4 (FOR6,EG15,FS17)
|
|
if (M_INTERNAL(OTFE) || M_EXTERNAL(OTFE))
|
|
{
|
|
bool SO = false; // "approximate same oriented (FOR,FS)"
|
|
// parEG :
|
|
double parEG;
|
|
bool ok = FUN_tool_parE(eON, parON, EG, parEG, tolEG);
|
|
if (!ok)
|
|
{
|
|
return; // nyiRAISE
|
|
}
|
|
// ntFS :
|
|
gp_Pnt2d uvFS;
|
|
ok = FUN_tool_paronEF(EG, parEG, FS, uvFS, tolFS); // !EGBoundFOR
|
|
if (!ok)
|
|
{
|
|
return; // nyiRAISE
|
|
}
|
|
gp_Vec ngFS = FUN_tool_nggeomF(uvFS, FS);
|
|
gp_Dir ntFS(ngFS);
|
|
if (M_REVERSED(oFS))
|
|
{
|
|
ntFS.Reverse();
|
|
}
|
|
// ntFOR :
|
|
gp_Pnt2d uvFOR;
|
|
ok = FUN_tool_parF(EG, parEG, FOR, uvFOR, tolFOR);
|
|
if (!ok)
|
|
{
|
|
return; // nyiRAISE
|
|
}
|
|
gp_Vec ngFOR = FUN_tool_nggeomF(uvFOR, FOR);
|
|
gp_Dir ntFOR(ngFOR);
|
|
if (M_REVERSED(oFOR))
|
|
{
|
|
ntFOR.Reverse();
|
|
}
|
|
|
|
double dot = ntFOR.Dot(ntFS);
|
|
bool nulldot = (std::abs(dot) < tola);
|
|
if (nulldot)
|
|
{
|
|
// xxFS :
|
|
gp_Dir xxFS;
|
|
ok = FUN_tool_getxx(FS, EG, parEG, ngFS, xxFS);
|
|
if (!ok)
|
|
{
|
|
return; // nyiRAISE
|
|
}
|
|
double dot2 = ntFOR.Dot(xxFS);
|
|
SO = (dot2 < 0.);
|
|
}
|
|
else
|
|
{
|
|
SO = (dot > 0.);
|
|
}
|
|
|
|
bool unkeepclo = false;
|
|
if (SO && M_EXTERNAL(OTFE) && opeCom)
|
|
{
|
|
unkeepclo = true;
|
|
}
|
|
if (SO && M_INTERNAL(OTFE) && opeFus)
|
|
{
|
|
unkeepclo = true;
|
|
}
|
|
addFORREV = !unkeepclo;
|
|
}
|
|
|
|
if (!addFORREV)
|
|
{
|
|
neworiEk = neworiE;
|
|
bool samegeom;
|
|
bool ok = FUN_tool_curvesSO(eON, EG, samegeom);
|
|
if (!ok)
|
|
{
|
|
return; // nyiRAISE
|
|
}
|
|
bool reverse = (!samegeom);
|
|
|
|
if (reverse)
|
|
{
|
|
neworiEk = TopAbs::Complement(neworiEk);
|
|
}
|
|
newE.Orientation(neworiEk);
|
|
}
|
|
|
|
#ifdef OCCT_DEBUG
|
|
if (tEFOR)
|
|
{
|
|
if (!addFORREV)
|
|
debaddpwes(iFOR, TB1, iEG, neworiEk, myPB, myPWES, "yapc3 GFillON", "WES+ EspON ");
|
|
else
|
|
{
|
|
debaddpwes(iFOR,
|
|
TB1,
|
|
iEG,
|
|
TopAbs_FORWARD,
|
|
myPB,
|
|
myPWES,
|
|
"yapc3 GFillON closed",
|
|
"WES+ EspON ");
|
|
debaddpwes(iFOR,
|
|
TB1,
|
|
iEG,
|
|
TopAbs_REVERSED,
|
|
myPB,
|
|
myPWES,
|
|
"yapc3 GFillON closed",
|
|
"WES+ EspON ");
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (addFORREV)
|
|
{
|
|
newE.Orientation(TopAbs_FORWARD);
|
|
myPWES->AddStartElement(newE);
|
|
newE.Orientation(TopAbs_REVERSED);
|
|
myPWES->AddStartElement(newE);
|
|
}
|
|
else
|
|
{
|
|
myPWES->AddStartElement(newE);
|
|
}
|
|
return;
|
|
} // yapc3
|
|
|
|
if (nlfcx == 0)
|
|
{
|
|
return;
|
|
}
|
|
const TopoDS_Face& FCX = TopoDS::Face(lfcx.First());
|
|
int iFCX = BDS.Shape(FCX);
|
|
|
|
// faces samedomain de FCX
|
|
NCollection_List<TopoDS_Shape> LFSO, LFDO, LFSO1, LFDO1, LFSO2, LFDO2;
|
|
myPB->GFindSamDomSODO(FCX, LFSO, LFDO);
|
|
int rankFCX = myPB->GShapeRank(FCX), rankX = (rankFCX) ? ((rankFCX == 1) ? 2 : 1) : 0;
|
|
// DEB : rankFCX doit etre=rankFS
|
|
|
|
// LFSO2,LFDO2=faces samedomain de FCX dans le shape oppose (rankX)
|
|
// rankX=shape oppose=shape de FOR.
|
|
myPB->GFindSameRank(LFSO, rankFCX, LFSO1);
|
|
myPB->GFindSameRank(LFDO, rankFCX, LFDO1);
|
|
myPB->GFindSameRank(LFSO, rankX, LFSO2);
|
|
myPB->GFindSameRank(LFDO, rankX, LFDO2);
|
|
|
|
// FFinSO=appartenance de FOR a l'ensemble des faces sameoriented de FCX=LFSO2
|
|
bool FFinSDSO = false;
|
|
{
|
|
for (NCollection_List<TopoDS_Shape>::Iterator i(LFSO2); i.More(); i.Next())
|
|
{
|
|
const TopoDS_Shape& F = i.Value();
|
|
if (F.IsSame(FOR))
|
|
{
|
|
FFinSDSO = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// FFinDO=appartenance de FOR a l'ensemble des faces difforiented de FCX=LFDO2
|
|
bool FFinSDDO = false;
|
|
{
|
|
for (NCollection_List<TopoDS_Shape>::Iterator i(LFDO2); i.More(); i.Next())
|
|
{
|
|
const TopoDS_Shape& F = i.Value();
|
|
if (F.IsSame(FOR))
|
|
{
|
|
FFinSDDO = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// FFinSD=appartenance de FOR a l'ensemble des faces samedomain de FCX
|
|
bool FFinSD = (FFinSDSO || FFinSDDO);
|
|
|
|
TopAbs_Orientation oFCX = BDS.Shape(iFCX).Orientation();
|
|
TopOpeBRepDS_Config cFCX = BDS.SameDomainOri(iFCX);
|
|
int irefFCX = BDS.SameDomainRef(FCX);
|
|
TopAbs_Orientation orefFCX = BDS.Shape(irefFCX).Orientation();
|
|
bool FCXisref = (irefFCX == iFCX);
|
|
|
|
#ifdef OCCT_DEBUG
|
|
// double tolFCX = factor*BRep_Tool::Tolerance(FCX); //NYITOLXPU
|
|
#endif
|
|
|
|
TopAbs_Orientation oegFCXF;
|
|
bool EGBoundFCX = FUN_tool_orientEinFFORWARD(EG, FCX, oegFCXF);
|
|
TopAbs_Orientation oegFCX;
|
|
FUN_tool_orientEinF(EG, FCX, oegFCX);
|
|
|
|
if (!EGBoundFOR && !espONesd)
|
|
{ // xpu220998 : ctocylcongA1 (FOR10,FS19,EG8)
|
|
gp_Pnt ptON;
|
|
bool ok = FUN_tool_value(parON, eON, ptON);
|
|
if (!ok)
|
|
{
|
|
return; // nyiRAISE
|
|
}
|
|
double d = 1.;
|
|
gp_Pnt2d uvFOR;
|
|
ok = FUN_tool_projPonboundedF(ptON, FOR, uvFOR, d);
|
|
if (!ok)
|
|
{
|
|
return; // nyiRAISE
|
|
}
|
|
double tolON = std::max(tolEG, tolFOR); // xpu291098 cto900L7(f7,e7on)
|
|
// xpu051198 PRO12953(f6,e4on)
|
|
tolON *= 1.e2; //*****CAREFUL***** : xpu040998, cto 904 A3
|
|
bool eONFOR = (d < tolON);
|
|
if (!eONFOR)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
bool yap1 = true;
|
|
yap1 = yap1 && FFinSD;
|
|
yap1 = yap1 && (!EGBoundFOR);
|
|
yap1 = yap1 && EGBoundFCX;
|
|
yap1 = yap1 && eghassd3dON;
|
|
|
|
bool yap2 = true;
|
|
yap2 = yap2 && FFinSD;
|
|
yap2 = yap2 && (!EGBoundFOR);
|
|
yap2 = yap2 && EGBoundFCX; // yap2 = yap2 && !eghassdON;
|
|
yap2 = yap2 && !eghassd; // yap2 = yap2 && !eghassd3dON;
|
|
|
|
bool yap1b = true;
|
|
yap1b = yap1b && FFinSD;
|
|
yap1b = yap1b && (!EGBoundFOR);
|
|
yap1b = yap1b && EGBoundFCX;
|
|
yap1b = yap1b && eghassd3d;
|
|
yap1b = yap1b && !eghassd3dON;
|
|
yap1b = yap1b && eONFS; // xpu240898
|
|
if (yap1b)
|
|
{
|
|
yap2 = true; // xpu220998 : ctocylcongA1 yap1b(FOR12,FS5,EG8)
|
|
}
|
|
|
|
bool yap6 = true; // cto001F3 : f18ou,EG=e23
|
|
yap6 = yap6 && FFinSD;
|
|
yap6 = yap6 && (!EGBoundFOR);
|
|
yap6 = yap6 && EGBoundFCX;
|
|
yap6 = yap6 && eghassdON;
|
|
yap6 = yap6 && !eghassd3d; // yap6 = yap6 && !eghassd3dON;
|
|
|
|
bool yap6b = true;
|
|
yap6b = yap6b && FFinSD;
|
|
yap6b = yap6b && (!EGBoundFOR);
|
|
yap6b = yap6b && EGBoundFCX;
|
|
yap6b = yap6b && eghassd;
|
|
yap6b = yap6b && !eghassdON;
|
|
yap6b = yap6b && eONFS; // xpu240898
|
|
yap6b = yap6b && !eghassd3d; // yap6b = yap6b && !eghassd3dON;
|
|
if (yap6b)
|
|
{
|
|
#ifdef OCCT_DEBUG
|
|
// FUN_RaiseON();
|
|
#endif
|
|
yap2 = true;
|
|
}
|
|
|
|
// CTS20205 spOUT(f30), e4 = eghassd3dON
|
|
// mais f30 !sdm lfcx(e4)
|
|
bool eghassd3fcx = eghassdON;
|
|
eghassd3fcx = eghassd3fcx && !FUN_ds_sdm(BDS, FOR, FS);
|
|
eghassd3fcx = eghassd3fcx && !FFinSD; //! FUN_ds_sdm(BDS,FOR,FCX)
|
|
bool yap5 = true;
|
|
yap5 = yap5 && !EGBoundFOR;
|
|
yap5 = yap5 && eghassd3fcx;
|
|
|
|
bool yap3 = true;
|
|
yap3 = yap3 && !FFinSD;
|
|
yap3 = yap3 && !EGBoundFOR;
|
|
yap3 = yap3 && eghassd3dON;
|
|
|
|
bool yap4 = true;
|
|
yap4 = yap4 && !FFinSD;
|
|
yap4 = yap4 && isrest;
|
|
yap4 = yap4 && !yap5;
|
|
yap4 = yap4 && !hsdFOR; // xpu290598
|
|
|
|
bool yap3b = true;
|
|
yap3b = yap3b && !FFinSD;
|
|
yap3b = yap3b && !EGBoundFOR;
|
|
yap3b = yap3b && eghassd3d;
|
|
yap3b = yap3b && !eghassd3dON;
|
|
yap3b = yap3b && eONFS; // xpu240898
|
|
if (yap3b)
|
|
{
|
|
yap4 = true; // xpu191098 : cto016F3(yap3b(FOR7,EG4))
|
|
}
|
|
|
|
// xpu290598
|
|
bool yap7 = true;
|
|
yap7 = yap7 && !FFinSD;
|
|
yap7 = yap7 && isrest;
|
|
yap7 = yap7 && !yap5;
|
|
yap7 = yap7 && hsdFOR;
|
|
|
|
TopAbs_State staFOR = TB1;
|
|
TopAbs_State staFS = (rankFS == rankFOR) ? TB1 : TB2;
|
|
|
|
#ifdef OCCT_DEBUG
|
|
// if(tEFOR) std::cout<<std::endl<<"yap1 yap2 yap3 yap4 = ";
|
|
// if(tEFOR) std::cout<<yap1<<" "<<yap2<<" "<<yap3<<" "<<yap4<<std::endl<<std::endl;
|
|
// if(tEFOR) debfillonfemess(iFOR,iEG);
|
|
#endif
|
|
|
|
//=========================================
|
|
if (yap1)
|
|
{
|
|
#ifdef OCCT_DEBUG
|
|
if (tEFOR)
|
|
debfillonfemess(iFOR, iEG, myPB, myPWES, "yap1 GFillON");
|
|
if (tE)
|
|
{
|
|
std::cout << "yap1(FOR" << iFOR << " FCX" << iFCX << " EG" << GI << ") ";
|
|
std::cout << "TB1=";
|
|
TopAbs::Print(TB1, std::cout);
|
|
std::cout << " TB2=";
|
|
TopAbs::Print(TB2, std::cout);
|
|
std::cout << std::endl;
|
|
}
|
|
|
|
#endif
|
|
|
|
// FF est samedomain avec FCX
|
|
// on evalue la transition de FOR par rapport a la matiere 2d de la face FCX
|
|
// au lieu de la transition par rapport a la matiere 3d de la face FS
|
|
// EG est une arete de FCX, oegFCXF=O.T. de EG dans FCX orientee FORWARD
|
|
// EG a des aretes 3d same domain : le3
|
|
|
|
TopAbs_State staFCX = staFS; // FS et FCX connexes par EG => meme shape origine => meme etat
|
|
bool b3d = false;
|
|
bool b2d = false;
|
|
|
|
// staFOR : etat demande sur FOR
|
|
bool b3de3 = false;
|
|
bool b2de3 = false;
|
|
|
|
const TopoDS_Edge& e3 = TopoDS::Edge(le3.First());
|
|
int ie3 = BDS.Shape(e3);
|
|
bool ssif = false;
|
|
occ::handle<TopOpeBRepDS_ShapeShapeInterference> ssie3;
|
|
NCollection_List<occ::handle<TopOpeBRepDS_Interference>>::Iterator itssi(
|
|
BDS.ShapeInterferences(FCX));
|
|
for (; itssi.More(); itssi.Next())
|
|
{
|
|
occ::handle<TopOpeBRepDS_ShapeShapeInterference> ssi(
|
|
occ::down_cast<TopOpeBRepDS_ShapeShapeInterference>(itssi.Value()));
|
|
if (ssi.IsNull())
|
|
{
|
|
continue;
|
|
}
|
|
TopOpeBRepDS_Kind GT1, ST1;
|
|
int G1, S1;
|
|
FDS_data(ssi, GT1, G1, ST1, S1);
|
|
bool cond = (GT1 == TopOpeBRepDS_EDGE && ST1 == TopOpeBRepDS_FACE);
|
|
cond = cond && (G1 == ie3);
|
|
// NYI cond = cond && e(S1 est une face connexe a iFOR par ie3)
|
|
if (cond)
|
|
{
|
|
ssif = true;
|
|
ssie3 = ssi;
|
|
break;
|
|
}
|
|
}
|
|
|
|
TopOpeBRepDS_Transition TFEe3;
|
|
TopAbs_State TFEe3bef = TFEe3.Before();
|
|
TopAbs_State TFEe3aft = TFEe3.After();
|
|
TopAbs_Orientation oe3FORF = TopAbs_FORWARD;
|
|
if (ssif)
|
|
{
|
|
TFEe3 = ssie3->Transition();
|
|
TFEe3bef = TFEe3.Before();
|
|
FUN_tool_orientEinFFORWARD(e3, FOR, oe3FORF);
|
|
}
|
|
|
|
if (FFinSDSO)
|
|
{
|
|
if (oFOR != oFCX)
|
|
{
|
|
oegFCXF = TopAbs::Complement(oegFCXF);
|
|
oe3FORF = TopAbs::Complement(oe3FORF);
|
|
}
|
|
TopOpeBRepDS_Transition T1(oegFCXF);
|
|
TopAbs_State T1aft = T1.After();
|
|
TopAbs_State T1bef = T1.Before();
|
|
if (oegFCXF == TopAbs_FORWARD)
|
|
{
|
|
b3d = (TFEaft == staFCX);
|
|
}
|
|
else if (oegFCXF == TopAbs_REVERSED)
|
|
{
|
|
b3d = (TFEbef == staFCX);
|
|
}
|
|
else
|
|
{
|
|
FUN_coutmess("DEBUG GFillONPartsWES2_1 orientation != F,R\n");
|
|
}
|
|
if (oegFCXF == TopAbs_FORWARD)
|
|
{
|
|
b2d = (T1aft == TopAbs_IN);
|
|
}
|
|
else if (oegFCXF == TopAbs_REVERSED)
|
|
{
|
|
b2d = (T1bef == TopAbs_IN);
|
|
}
|
|
else
|
|
{
|
|
FUN_coutmess("DEBUG GFillONPartsWES2_2 orientation != F,R\n");
|
|
}
|
|
|
|
if (ssif)
|
|
{
|
|
TopOpeBRepDS_Transition T11(oe3FORF);
|
|
TopAbs_State T11aft = T11.After();
|
|
TopAbs_State T11bef = T11.Before();
|
|
if (oe3FORF == TopAbs_FORWARD)
|
|
{
|
|
b3de3 = (TFEe3aft == staFOR);
|
|
}
|
|
else if (oe3FORF == TopAbs_REVERSED)
|
|
{
|
|
b3de3 = (TFEe3bef == staFOR);
|
|
}
|
|
else
|
|
{
|
|
FUN_coutmess("DEBUG GFillONPartsWES2_1 orientation != F,R\n");
|
|
}
|
|
if (oe3FORF == TopAbs_FORWARD)
|
|
{
|
|
b2de3 = (T11aft == TopAbs_IN);
|
|
}
|
|
else if (oe3FORF == TopAbs_REVERSED)
|
|
{
|
|
b2de3 = (T11bef == TopAbs_IN);
|
|
}
|
|
else
|
|
{
|
|
FUN_coutmess("DEBUG GFillONPartsWES2_2 orientation != F,R\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (FFinSDDO)
|
|
{
|
|
if (oFOR == oFCX)
|
|
{
|
|
oegFCXF = TopAbs::Complement(oegFCXF);
|
|
oe3FORF = TopAbs::Complement(oe3FORF);
|
|
}
|
|
TopOpeBRepDS_Transition T2(oegFCXF);
|
|
TopAbs_State Taft = T2.After();
|
|
TopAbs_State Tbef = T2.Before();
|
|
if (oegFCXF == TopAbs_FORWARD)
|
|
{
|
|
b3d = (TFEaft == staFCX);
|
|
}
|
|
else if (oegFCXF == TopAbs_REVERSED)
|
|
{
|
|
b3d = (TFEbef == staFCX);
|
|
}
|
|
else
|
|
{
|
|
FUN_coutmess("DEBUG GFillONPartsWES2_3 orientation != F,R\n");
|
|
}
|
|
if (oegFCXF == TopAbs_FORWARD)
|
|
{
|
|
b2d = (Taft == TopAbs_IN);
|
|
}
|
|
else if (oegFCXF == TopAbs_REVERSED)
|
|
{
|
|
b2d = (Tbef == TopAbs_IN);
|
|
}
|
|
else
|
|
{
|
|
FUN_coutmess("DEBUG GFillONPartsWES2_4 orientation != F,R\n");
|
|
}
|
|
|
|
if (ssif)
|
|
{
|
|
TopOpeBRepDS_Transition T22(oe3FORF);
|
|
TopAbs_State T22aft = T22.After();
|
|
TopAbs_State T22bef = T22.Before();
|
|
if (oe3FORF == TopAbs_FORWARD)
|
|
{
|
|
b3de3 = (TFEe3aft == staFOR);
|
|
}
|
|
else if (oe3FORF == TopAbs_REVERSED)
|
|
{
|
|
b3de3 = (TFEe3bef == staFOR);
|
|
}
|
|
else
|
|
{
|
|
FUN_coutmess("DEBUG GFillONPartsWES2_3 orientation != F,R\n");
|
|
}
|
|
if (oe3FORF == TopAbs_FORWARD)
|
|
{
|
|
b2de3 = (T22aft == TopAbs_IN);
|
|
}
|
|
else if (oe3FORF == TopAbs_REVERSED)
|
|
{
|
|
b2de3 = (T22bef == TopAbs_IN);
|
|
}
|
|
else
|
|
{
|
|
FUN_coutmess("DEBUG GFillONPartsWES2_4 orientation != F,R\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
bool b = (b3d && b2d && b3de3 && b2de3);
|
|
if (!b)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// on garde EspON pour la reconstruction de la face FOR
|
|
// si elle est IN/ON la face FOR (EGBoundFOR = 0 ==> projection)
|
|
TopOpeBRepTool_ShapeClassifier& PSC = FSC_GetPSC(FOR);
|
|
TopAbs_State state2d = FSC_StateEonFace(EspON, 0.345, FOR, PSC);
|
|
bool isin = (state2d == TopAbs_IN);
|
|
if (!isin)
|
|
{
|
|
return;
|
|
}
|
|
|
|
TopAbs_State TBEG = TB1;
|
|
TopAbs_Orientation neworiE = TFE.Orientation(TBEG);
|
|
|
|
// if (FCXisref && FFinSDDO) {
|
|
if (FCXisref && !EGBoundFOR)
|
|
{
|
|
FUN_tool_orientEinFFORWARD(EG, FCX, neworiE);
|
|
bool rev = TopOpeBRepBuild_Builder::Reverse(staFCX, staFOR);
|
|
neworiE = TopOpeBRepBuild_Builder::Orient(neworiE, rev);
|
|
}
|
|
// xpu280798 : never occurs as yap1 -> !EGBoundFOR
|
|
// else if (FORisref && EGBoundFOR) {
|
|
// FUN_tool_orientEinFFORWARD(EG,FOR,neworiE);
|
|
// bool rev = myPB->Reverse(staFOR,staFCX);
|
|
// neworiE = myPB->Orient(neworiE,rev);
|
|
// }
|
|
else if (FORisref && !EGBoundFOR)
|
|
{
|
|
const TopoDS_Edge& Esd = TopoDS::Edge(BDS.Shape(Iesd));
|
|
FUN_tool_orientEinFFORWARD(Esd, TopoDS::Face(FOR), neworiE);
|
|
bool reverse = (M_FORWARD(neworiE) || M_REVERSED(neworiE)) && (!eONsoEsd);
|
|
if (reverse)
|
|
{
|
|
neworiE = TopAbs::Complement(neworiE);
|
|
}
|
|
bool rev = TopOpeBRepBuild_Builder::Reverse(staFOR, staFCX);
|
|
neworiE = TopOpeBRepBuild_Builder::Orient(neworiE, rev);
|
|
}
|
|
else if (!EGBoundFOR)
|
|
{ // xpu210898
|
|
int rankrefFOR = BDS.AncestorRank(irefFOR);
|
|
if (rankrefFOR == rankFCX)
|
|
{
|
|
FUN_tool_orientEinFFORWARD(EG, FCX, neworiE);
|
|
}
|
|
else if (rankrefFOR == rankFOR)
|
|
{
|
|
const TopoDS_Edge& Esd = TopoDS::Edge(BDS.Shape(Iesd));
|
|
FUN_tool_orientEinFFORWARD(Esd, TopoDS::Face(FOR), neworiE);
|
|
bool reverse = (M_FORWARD(neworiE) || M_REVERSED(neworiE)) && (!eONsoEsd);
|
|
if (reverse)
|
|
{
|
|
neworiE = TopAbs::Complement(neworiE);
|
|
}
|
|
}
|
|
bool rev = TopOpeBRepBuild_Builder::Reverse(staFOR, staFCX);
|
|
neworiE = TopOpeBRepBuild_Builder::Orient(neworiE, rev);
|
|
}
|
|
|
|
TopoDS_Shape newE = EspON;
|
|
newE.Orientation(neworiE);
|
|
|
|
#ifdef OCCT_DEBUG
|
|
if (tEFOR)
|
|
debaddpwes(iFOR, TB1, iEG, neworiE, myPB, myPWES, "yap1 GFillON", "WES+ EspON ");
|
|
if (tE)
|
|
FUN_cout(newE);
|
|
#endif
|
|
myPWES->AddStartElement(newE);
|
|
|
|
return;
|
|
} // yap1
|
|
|
|
//=========================================
|
|
if (yap2)
|
|
{
|
|
#ifdef OCCT_DEBUG
|
|
if (tEFOR)
|
|
debfillonfemess(iFOR, iEG, myPB, myPWES, "yap2 GFillON");
|
|
if (tE)
|
|
{
|
|
std::cout << "yap2(FOR" << iFOR << " FCX" << iFCX << " EG" << GI << ") ";
|
|
std::cout << "TB1=";
|
|
TopAbs::Print(TB1, std::cout);
|
|
std::cout << " TB2=";
|
|
TopAbs::Print(TB2, std::cout);
|
|
std::cout << std::endl;
|
|
}
|
|
#endif
|
|
|
|
// FF est samedomain avec FCX
|
|
// on evalue la transition de FOR par rapport a la matiere 2d de la face FCX
|
|
// au lieu de la transition par rapport a la matiere 3d de la face FS
|
|
// EG est une arete de FCX, oegFCXF=O.T. de EG dans FCX orientee FORWARD
|
|
|
|
TopAbs_State staFCX = staFS; // FS et FCX connexes par EG => meme shape origine => meme etat
|
|
bool b3d = false;
|
|
bool b2d = false;
|
|
bool b = (b3d && b2d);
|
|
|
|
if (FFinSDSO)
|
|
{
|
|
if (oFOR != oFCX)
|
|
{
|
|
// orientation topologique de EG dans la face mere
|
|
oegFCXF = TopAbs::Complement(oegFCXF);
|
|
}
|
|
TopOpeBRepDS_Transition T1(oegFCXF);
|
|
TopAbs_State Taft = T1.After();
|
|
TopAbs_State Tbef = T1.Before();
|
|
if (oegFCXF == TopAbs_FORWARD)
|
|
{
|
|
b3d = (TFEaft == staFCX);
|
|
}
|
|
else if (oegFCXF == TopAbs_REVERSED)
|
|
{
|
|
b3d = (TFEbef == staFCX);
|
|
}
|
|
else
|
|
{
|
|
FUN_coutmess("DEBUG GFillONPartsWES2_1 orientation != F,R\n");
|
|
}
|
|
if (oegFCXF == TopAbs_FORWARD)
|
|
{
|
|
b2d = (Taft == TopAbs_IN);
|
|
}
|
|
else if (oegFCXF == TopAbs_REVERSED)
|
|
{
|
|
b2d = (Tbef == TopAbs_IN);
|
|
}
|
|
else
|
|
{
|
|
FUN_coutmess("DEBUG GFillONPartsWES2_2 orientation != F,R\n");
|
|
}
|
|
}
|
|
if (FFinSDDO)
|
|
{
|
|
if (oFOR == oFCX)
|
|
{
|
|
// orientation topologique de EG dans la face mere
|
|
oegFCXF = TopAbs::Complement(oegFCXF);
|
|
}
|
|
TopOpeBRepDS_Transition T2(oegFCXF);
|
|
TopAbs_State Taft = T2.After();
|
|
TopAbs_State Tbef = T2.Before();
|
|
if (oegFCXF == TopAbs_FORWARD)
|
|
{
|
|
b3d = (TFEaft == staFCX);
|
|
}
|
|
else if (oegFCXF == TopAbs_REVERSED)
|
|
{
|
|
b3d = (TFEbef == staFCX);
|
|
}
|
|
else
|
|
{
|
|
FUN_coutmess("DEBUG GFillONPartsWES2_3 orientation != F,R\n");
|
|
}
|
|
if (oegFCXF == TopAbs_FORWARD)
|
|
{
|
|
b2d = (Taft == TopAbs_IN);
|
|
}
|
|
else if (oegFCXF == TopAbs_REVERSED)
|
|
{
|
|
b2d = (Tbef == TopAbs_IN);
|
|
}
|
|
else
|
|
{
|
|
FUN_coutmess("DEBUG GFillONPartsWES2_4 orientation != F,R\n");
|
|
}
|
|
}
|
|
// #ifdef OCCT_DEBUG
|
|
// if(tEFOR) {std::cout<<std::endl<<"yap2 : b3d,b2d
|
|
// "<<b3d<<","<<b2d<<std::endl;debfillonfemess(iFOR,iEG);}
|
|
// #endif
|
|
|
|
// bcl1;bcl2; c12;tsp(f9),tspON(e7)
|
|
if (ComOfCut)
|
|
{
|
|
b3d = true;
|
|
b2d = true;
|
|
} // xpu200598
|
|
|
|
gp_Vec ngFS, ngFOR;
|
|
double parEG = 0.;
|
|
// bcl1;bcl2; tsp(f9),tspON(e7)
|
|
bool sdm = FUN_ds_sdm(BDS, BDS.Shape(iFOR), BDS.Shape(iFS));
|
|
bool isfafa = sdm; // such interferences are computed IN fafa case
|
|
if (!isfafa)
|
|
{
|
|
// parEG :
|
|
bool ok = FUN_tool_parE(eON, parON, EG, parEG, tolEG);
|
|
if (!ok)
|
|
{
|
|
return;
|
|
}
|
|
// xxFS :
|
|
gp_Pnt2d uvFS;
|
|
ok = FUN_tool_parF(EG, parEG, FS, uvFS, tolFS);
|
|
if (!ok)
|
|
{
|
|
return; // nyiRAISE
|
|
}
|
|
ngFS = FUN_tool_nggeomF(uvFS, FS);
|
|
gp_Dir xxFS;
|
|
ok = FUN_tool_getxx(FS, EG, parEG, ngFS, xxFS);
|
|
if (!ok)
|
|
{
|
|
return; // nyiRAISE
|
|
}
|
|
// ntFOR :
|
|
gp_Pnt2d uvFOR;
|
|
ok = FUN_tool_parF(EG, parEG, FOR, uvFOR, tolFOR);
|
|
if (!ok)
|
|
{
|
|
return; // nyiRAISE
|
|
}
|
|
ngFOR = FUN_tool_nggeomF(uvFOR, FOR);
|
|
gp_Dir ntFOR(ngFOR);
|
|
if (M_REVERSED(oFOR))
|
|
{
|
|
ntFOR.Reverse();
|
|
}
|
|
|
|
double dot = xxFS.Dot(ntFOR);
|
|
// xpu040698 : FS tg to FCX at EG - CTS20578 (FOR=F8,EG=E6,FS=F4) -
|
|
bool nulldot = (std::abs(dot) < tola);
|
|
if (nulldot)
|
|
{ // approximate xxFS :
|
|
gp_Pnt2d newuvFS;
|
|
gp_Vec2d dxx;
|
|
ok = FUN_tool_getdxx(FS, EG, parEG, dxx);
|
|
if (!ok)
|
|
{
|
|
return;
|
|
}
|
|
newuvFS = uvFS.Translated(dxx * 0.25);
|
|
gp_Dir newngFS = FUN_tool_nggeomF(newuvFS, FS);
|
|
ok = FUN_tool_getxx(FS, EG, parEG, newngFS, xxFS);
|
|
if (!ok)
|
|
{
|
|
return;
|
|
}
|
|
dot = xxFS.Dot(ntFOR);
|
|
}
|
|
// xpu040698
|
|
|
|
TopAbs_State TBFS = FUN_build_TB(myPB, rankFS);
|
|
bool positive = (dot > 0);
|
|
|
|
bool keep = true;
|
|
if (FFinSDSO)
|
|
{
|
|
if (opeFus)
|
|
{
|
|
keep = positive; // xpu090698 : PRO14033 (iFOR=15,GI=10,iFS=9)
|
|
}
|
|
if (opeCom)
|
|
{
|
|
keep = true;
|
|
}
|
|
if (opeCut)
|
|
{
|
|
if (positive)
|
|
{
|
|
keep = (TBFS == TopAbs_OUT); // xpu230698 cto100G1
|
|
}
|
|
else
|
|
{
|
|
keep = (TBFS == TopAbs_IN);
|
|
}
|
|
}
|
|
}
|
|
if (FFinSDDO)
|
|
{
|
|
if (opeFus)
|
|
{
|
|
keep = positive;
|
|
// xpu050698 : (fuse = OU/IN + IN/OU) -CTS20578-
|
|
if (keep)
|
|
{
|
|
int rkOU = (TB1 == TopAbs_OUT) ? 1 : 2;
|
|
int rkfspOU = (rankFOR == rkOU) ? 1 : 2;
|
|
bool spOUFOR = (rankFOR == rkfspOU);
|
|
keep = spOUFOR;
|
|
}
|
|
}
|
|
if (opeCom)
|
|
{
|
|
keep = !positive;
|
|
}
|
|
if (opeCut)
|
|
{
|
|
bool FORmoinsFS = (TBFS == TopAbs_IN);
|
|
if (positive)
|
|
{
|
|
if (FORmoinsFS)
|
|
{
|
|
keep = true;
|
|
}
|
|
else
|
|
{
|
|
keep = ComOfCut;
|
|
}
|
|
// if (TBFS == TopAbs_OUT) keep = true;
|
|
// else keep = (rankFS == 1);
|
|
}
|
|
else
|
|
{
|
|
// keep = !FORmoinsFS; // xpu230698 : cto100A1
|
|
// keep = false;
|
|
if (!FORmoinsFS)
|
|
{
|
|
keep = true; // xpu230698 : cto100A1
|
|
}
|
|
else
|
|
{
|
|
keep = ComOfCut; // xpu120898 PRO12859 (FOR26,FS12,FCX18,EG14)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// #ifdef OCCT_DEBUG
|
|
// if(tEFOR) {std::cout<<std::endl<<"yap2 : keep
|
|
// "<<keep<<std::endl;debfillonfemess(iFOR,iEG);}
|
|
// #endif
|
|
if (!keep)
|
|
{
|
|
return;
|
|
}
|
|
} // !isfafa
|
|
else
|
|
{
|
|
if (!b)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
// on garde EspON pour la reconstruction de la face FOR
|
|
// si elle est IN/ON la face FOR (EGBoundFOR = 0 ==> projection)
|
|
TopOpeBRepTool_ShapeClassifier& PSC = FSC_GetPSC(FOR);
|
|
TopAbs_State state2d = FSC_StateEonFace(EspON, 0.345, FOR, PSC);
|
|
bool isin = (state2d == TopAbs_IN);
|
|
if (!isin)
|
|
{
|
|
return;
|
|
}
|
|
|
|
TopAbs_State TBEG = TB1;
|
|
TopAbs_Orientation neworiE = TFE.Orientation(TBEG);
|
|
|
|
FUN_tool_orientEinFFORWARD(EG, FCX, neworiE);
|
|
bool forw = M_FORWARD(neworiE), reve = M_REVERSED(neworiE);
|
|
bool ok = forw || reve;
|
|
if (FFinSDSO && ok)
|
|
{
|
|
if (opeCut)
|
|
{
|
|
neworiE = TopAbs::Complement(neworiE);
|
|
}
|
|
} // FFinSDSO && ok
|
|
|
|
// bcl1;bcl2; tsp(f9)
|
|
if (FFinSDDO && ok)
|
|
{
|
|
if (opeCut)
|
|
{
|
|
if (!ComOfCut)
|
|
{
|
|
// TopAbs_State TBEG = (rankEG == 1)? TB1 : TB2;
|
|
// if (TBEG == TopAbs_IN) neworiE = TopAbs::Complement(neworiE);
|
|
neworiE = TopAbs::Complement(neworiE); // xpu270898 : cto905E2 (FOR33,FCX16,EG19)
|
|
}
|
|
else if (ComOfCut)
|
|
{
|
|
// rien a faire
|
|
}
|
|
}
|
|
if (opeFus)
|
|
{
|
|
// en principe , l'operation locale est tjrs = OUT,IN
|
|
neworiE = TopAbs::Complement(neworiE);
|
|
}
|
|
if (opeCom)
|
|
{
|
|
// SDDO et oT anti// => oG //
|
|
// xxFCX :
|
|
gp_Dir xxFCX;
|
|
ok = FUN_tool_getxx(FCX, EG, parEG, xxFCX);
|
|
if (!ok)
|
|
{
|
|
return; // nyiRAISE
|
|
}
|
|
// ntFS :
|
|
gp_Dir ntFS(ngFS);
|
|
if (M_REVERSED(oFS))
|
|
{
|
|
ntFS.Reverse();
|
|
}
|
|
|
|
double dot = xxFCX.Dot(ntFS);
|
|
bool toreverse = (dot > 0);
|
|
|
|
if (toreverse)
|
|
{
|
|
neworiE = TopAbs::Complement(neworiE);
|
|
}
|
|
}
|
|
} // FFinSDDO && ok
|
|
|
|
bool reverse = false; // xpu270598 : reverse=false=>FCX has same geom ori
|
|
if (!FCXisref)
|
|
{ // xpu270598
|
|
if (cFCX == TopOpeBRepDS_DIFFORIENTED)
|
|
{
|
|
reverse = true;
|
|
}
|
|
if (oFCX != orefFCX)
|
|
{
|
|
reverse = !reverse;
|
|
}
|
|
} // xpu270598
|
|
if (reverse)
|
|
{
|
|
neworiE = TopAbs::Complement(neworiE); // xpu270598
|
|
}
|
|
|
|
TopoDS_Shape newE = EspON;
|
|
newE.Orientation(neworiE);
|
|
|
|
#ifdef OCCT_DEBUG
|
|
if (tEFOR)
|
|
debaddpwes(iFOR, TB1, iEG, neworiE, myPB, myPWES, "yap2 GFillON", "WES+ EspON ");
|
|
if (tE)
|
|
FUN_cout(newE);
|
|
#endif
|
|
myPWES->AddStartElement(newE);
|
|
|
|
return;
|
|
} // yap2
|
|
|
|
//=========================================
|
|
if (yap6)
|
|
{
|
|
#ifdef OCCT_DEBUG
|
|
if (tEFOR)
|
|
debfillonfemess(iFOR, iEG, myPB, myPWES, "yap6 GFillON");
|
|
if (tE)
|
|
{
|
|
std::cout << "yap6(FOR" << iFOR << " FCX" << iFCX << " EG" << GI << ") ";
|
|
std::cout << "TB1=";
|
|
TopAbs::Print(TB1, std::cout);
|
|
std::cout << " TB2=";
|
|
TopAbs::Print(TB2, std::cout);
|
|
std::cout << std::endl;
|
|
}
|
|
#endif
|
|
TopAbs_Orientation neworiE;
|
|
// FF est samedomain avec FCX
|
|
// on evalue la transition de FOR par rapport a la matiere 2d de la face FCX
|
|
// au lieu de la transition par rapport a la matiere 3d de la face FS
|
|
// EG est une arete de FCX, oegFCXF=O.T. de EG dans FCX orientee FORWARD
|
|
|
|
TopAbs_State staFCX = staFS; // FS et FCX connexes par EG => meme shape origine => meme etat
|
|
bool b3d = false;
|
|
bool b2d = false;
|
|
bool b = false;
|
|
|
|
bool SO = FFinSDSO; //(FFinSDSO && (oFOR == oFCX)) || (FFinSDDO && (oFOR != oFCX));
|
|
bool DO = FFinSDDO; //(FFinSDSO && (oFOR != oFCX)) || (FFinSDDO && (oFOR == oFCX));
|
|
|
|
#ifdef OCCT_DEBUG
|
|
// int rkToFill = BDS.AncestorRank(myFace);
|
|
#endif
|
|
// bool samerk = (rankEG == rkToFill);
|
|
|
|
// TopAbs_Orientation oegFOR;
|
|
bool shareG;
|
|
bool ok = FUN_ds_shareG(myPB->DataStructure(), iFOR, iFCX, GI, TopoDS::Edge(EspON), shareG);
|
|
if (!ok)
|
|
{
|
|
return; // nyiFUNRAISE
|
|
}
|
|
|
|
if (SO)
|
|
{
|
|
// FOR and FCX share geometric domain.
|
|
bool forcekeep = opeFus && shareG && (rankEG == 1); // newnew
|
|
|
|
if (opeFus)
|
|
{
|
|
// b = shareG;
|
|
// xpu231198 :PRO15946 (FOR11,EG24,FCX20)
|
|
// xpu090299 (JAP60247, FOR6,FCX33,EG34)
|
|
const TopoDS_Edge& Esd = TopoDS::Edge(BDS.Shape(Iesd));
|
|
NCollection_List<TopoDS_Shape> lfor;
|
|
FDSCNX_FaceEdgeConnexFaces(FOR, Esd, HDS, lfor);
|
|
int nfor = lfor.Extent();
|
|
if (nfor < 1)
|
|
{
|
|
b = shareG; // Esd is FOR's closing edge
|
|
}
|
|
else if (nfor > 1)
|
|
{
|
|
return; // NYIRaise (invalid shape)
|
|
}
|
|
else
|
|
{
|
|
const TopoDS_Face& FF = TopoDS::Face(lfor.First());
|
|
double tola1 = Precision::Angular() * 1.e2; // nyitolxpu
|
|
double parEG;
|
|
bool ok1 = FUN_tool_parE(eON, parON, EG, parEG, tolEG);
|
|
if (!ok1)
|
|
{
|
|
return;
|
|
}
|
|
double matfs;
|
|
ok1 = TopOpeBRepTool_TOOL::Matter(FS, FCX, EG, parEG, tola1, matfs);
|
|
if (!ok1)
|
|
{
|
|
return;
|
|
}
|
|
|
|
double tolEsd = BRep_Tool::Tolerance(Esd) * factor; // NYITOLXPU
|
|
double parEsd;
|
|
bool ok2 = FUN_tool_parE(eON, parON, Esd, parEsd, tolEsd);
|
|
if (!ok2)
|
|
{
|
|
return;
|
|
}
|
|
double matfor;
|
|
ok2 = TopOpeBRepTool_TOOL::Matter(FOR, FF, Esd, parEsd, tola1, matfor);
|
|
if (!ok2)
|
|
{
|
|
return;
|
|
}
|
|
|
|
double sum = matfs + matfor;
|
|
bool sumisPI = (std::abs(sum - M_PI) < tola1);
|
|
bool fsinfPI = (matfs < M_PI);
|
|
bool forinfPI = (matfor < M_PI);
|
|
if (sumisPI)
|
|
{
|
|
b = false;
|
|
}
|
|
else if (sum < M_PI)
|
|
{
|
|
b = true;
|
|
}
|
|
else
|
|
{ // sum > M_PI
|
|
if (fsinfPI && forinfPI)
|
|
{
|
|
b = false;
|
|
}
|
|
else
|
|
{ // (!fsinfPI) || (!forinfPI)
|
|
bool sammat = (std::abs(matfs - matfor) < tola1);
|
|
if (sammat)
|
|
{
|
|
b = false;
|
|
}
|
|
else
|
|
{
|
|
b = (matfs < matfor);
|
|
}
|
|
}
|
|
}
|
|
if (b)
|
|
{
|
|
forcekeep = true;
|
|
}
|
|
}
|
|
// NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNYIXPU
|
|
/*if (shareG) b = true;
|
|
else {
|
|
// xpu231198 :PRO15946 (FOR11,EG24,FCX20)
|
|
double parEG; bool ok = FUN_tool_parE(eON,parON,EG,parEG,tolEG);
|
|
if (!ok) return;
|
|
gp_Dir xxFCX; ok = FUN_tool_getxx(FCX,EG,parEG,xxFCX);
|
|
if (!ok) return;// nyiRAISE
|
|
gp_Vec ntFS; ok = FUN_tool_nggeomF(parEG,EG,FS,ntFS,tolFS);
|
|
if (!ok) return;// nyiRAISE
|
|
if (M_REVERSED(oFS)) ntFS.Reverse();
|
|
|
|
double dot = ntFS.Dot(xxFCX);
|
|
if (std::abs(dot) < tola) b = false; // xpu231198nyi tangent config
|
|
else {b = (dot <0.); if (b) forcekeep=true;}
|
|
}//!shareG*/
|
|
}
|
|
else if (opeCut)
|
|
{
|
|
b = (!shareG);
|
|
}
|
|
else if (opeCom)
|
|
{
|
|
b = shareG && (rankEG == 1);
|
|
}
|
|
if (b)
|
|
{ // nyi : a revoir
|
|
if (oFOR != oFCX)
|
|
{
|
|
// orientation topologique de EG dans la face mere
|
|
oegFCXF = TopAbs::Complement(oegFCXF);
|
|
}
|
|
TopOpeBRepDS_Transition T1(oegFCXF);
|
|
TopAbs_State Taft = T1.After();
|
|
TopAbs_State Tbef = T1.Before();
|
|
if (oegFCXF == TopAbs_FORWARD)
|
|
{
|
|
b3d = (TFEaft == staFCX);
|
|
}
|
|
else if (oegFCXF == TopAbs_REVERSED)
|
|
{
|
|
b3d = (TFEbef == staFCX);
|
|
}
|
|
if (oegFCXF == TopAbs_FORWARD)
|
|
{
|
|
b2d = (Taft == TopAbs_IN);
|
|
}
|
|
else if (oegFCXF == TopAbs_REVERSED)
|
|
{
|
|
b2d = (Tbef == TopAbs_IN);
|
|
}
|
|
b = (b3d && b2d);
|
|
}
|
|
if (forcekeep)
|
|
{
|
|
b = true; // newnew
|
|
}
|
|
}
|
|
if (DO)
|
|
{ // we do NOT keep the splitON
|
|
if (opeFus)
|
|
{
|
|
b = (!shareG); // cto001D2 spOU(f18)
|
|
}
|
|
if (opeCut)
|
|
{
|
|
int rankREF = opec12 ? 1 : 2;
|
|
bool binin = false, binou = false;
|
|
if (TB1 == TB2)
|
|
{
|
|
binin = (rankEG == rankREF); // partie IN/IN
|
|
}
|
|
else
|
|
{
|
|
// xpu291098 cto001D3 (f17ou)
|
|
binou = (rankFOR == 1) && (TBFOR == TopAbs_OUT) && (!shareG);
|
|
if (binou)
|
|
{
|
|
// xpu181198 CTS21302(FOR22,EG9,FCX5)
|
|
// ntOOFOR :
|
|
const TopoDS_Edge& Esd = TopoDS::Edge(BDS.Shape(Iesd)); // rkEsd=rkFOR
|
|
NCollection_List<TopoDS_Shape> lfcFk;
|
|
FDSCNX_FaceEdgeConnexFaces(FOR, Esd, HDS, lfcFk);
|
|
if (lfcFk.Extent() != 1)
|
|
{
|
|
return; // shape bizarre
|
|
}
|
|
double parEsd;
|
|
ok = FUN_tool_parE(eON, parON, Esd, parEsd, tolEG);
|
|
if (!ok)
|
|
{
|
|
return;
|
|
}
|
|
const TopoDS_Face& OOFOR = TopoDS::Face(lfcFk.First());
|
|
gp_Pnt2d uv;
|
|
double dummy = 0;
|
|
ok = FUN_tool_paronEF(Esd, parEsd, OOFOR, uv, dummy); // rkEsd=rkOOFOR
|
|
gp_Vec ntOOFOR = FUN_tool_nggeomF(uv, OOFOR);
|
|
if (OOFOR.Orientation() == TopAbs_REVERSED)
|
|
{
|
|
ntOOFOR.Reverse();
|
|
}
|
|
// xxFCX :
|
|
#ifdef OCCT_DEBUG
|
|
// double t1 =factor*BRep_Tool::Tolerance(Esd);
|
|
#endif
|
|
double parEG;
|
|
ok = FUN_tool_parE(Esd, parEsd, EG, parEG);
|
|
if (!ok)
|
|
{
|
|
return;
|
|
}
|
|
gp_Dir xxFCX;
|
|
ok = FUN_tool_getxx(FCX, EG, parEG, xxFCX);
|
|
if (!ok)
|
|
{
|
|
return;
|
|
}
|
|
// dot :
|
|
double dot = ntOOFOR.Dot(xxFCX);
|
|
if (std::abs(dot) < tola)
|
|
{
|
|
binou = true; // nyixpu181198
|
|
}
|
|
else if (dot < 0.)
|
|
{
|
|
binou = false;
|
|
}
|
|
}
|
|
}
|
|
b = binin || binou;
|
|
}
|
|
}
|
|
if (!b)
|
|
{
|
|
return;
|
|
}
|
|
|
|
TopAbs_State TBEG = TB1;
|
|
neworiE = TFE.Orientation(TBEG);
|
|
if (FCXisref && !EGBoundFOR)
|
|
{
|
|
FUN_tool_orientEinFFORWARD(EG, FCX, neworiE);
|
|
bool rev = TopOpeBRepBuild_Builder::Reverse(staFCX, staFOR);
|
|
neworiE = TopOpeBRepBuild_Builder::Orient(neworiE, rev);
|
|
}
|
|
else if (FORisref && !EGBoundFOR)
|
|
{
|
|
// xpu280798 : cto902C1 (FOR=f9,FCX=f19,FS,f33,EG,e18)
|
|
// as eghassdON : Esd = edge(Iesd) = bound FOR; eON is IN1d(Esd)
|
|
const TopoDS_Edge& Esd = TopoDS::Edge(BDS.Shape(Iesd));
|
|
FUN_tool_orientEinFFORWARD(Esd, TopoDS::Face(FOR), neworiE);
|
|
bool reverse = (M_FORWARD(neworiE) || M_REVERSED(neworiE)) && (!eONsoEsd);
|
|
if (reverse)
|
|
{
|
|
neworiE = TopAbs::Complement(neworiE);
|
|
}
|
|
bool rev = TopOpeBRepBuild_Builder::Reverse(staFOR, staFCX);
|
|
neworiE = TopOpeBRepBuild_Builder::Orient(neworiE, rev);
|
|
}
|
|
else if (!EGBoundFOR)
|
|
{
|
|
// xpu210898 : CTS20875 : yap6(FOR13,GI15,FCX6), !FCXisref && !FORisref
|
|
int rankrefFOR = BDS.AncestorRank(irefFOR);
|
|
if (rankrefFOR == rankFCX)
|
|
{
|
|
FUN_tool_orientEinFFORWARD(EG, FCX, neworiE);
|
|
}
|
|
else if (rankrefFOR == rankFOR)
|
|
{
|
|
const TopoDS_Edge& Esd = TopoDS::Edge(BDS.Shape(Iesd));
|
|
FUN_tool_orientEinFFORWARD(Esd, TopoDS::Face(FOR), neworiE);
|
|
bool reverse = (M_FORWARD(neworiE) || M_REVERSED(neworiE)) && (!eONsoEsd);
|
|
if (reverse)
|
|
{
|
|
neworiE = TopAbs::Complement(neworiE);
|
|
}
|
|
}
|
|
bool rev = TopOpeBRepBuild_Builder::Reverse(staFOR, staFCX);
|
|
neworiE = TopOpeBRepBuild_Builder::Orient(neworiE, rev);
|
|
}
|
|
|
|
TopoDS_Shape newE = EspON;
|
|
newE.Orientation(neworiE);
|
|
#ifdef OCCT_DEBUG
|
|
if (tEFOR)
|
|
debaddpwes(iFOR, TB1, iEG, neworiE, myPB, myPWES, "yap6 GFillON", "WES+ EspON ");
|
|
if (tE)
|
|
FUN_cout(newE);
|
|
#endif
|
|
myPWES->AddStartElement(newE);
|
|
|
|
// xpu290798 : cto 902 C1, f9ou,f19in, spON(e7) = spON(e18)
|
|
// splits IN and OUT generated on reference surface should be diff oriented
|
|
// they share same edge eON which is FORWARD in one, REVERSED in the other
|
|
bool addtwice = SO && !shareG && opeCut;
|
|
addtwice = addtwice && (M_FORWARD(neworiE) || M_REVERSED(neworiE));
|
|
if (addtwice)
|
|
{
|
|
// we have splitIN
|
|
TopoDS_Shape FtospIN = (TBFOR == TopAbs_IN) ? FOR : FCX;
|
|
addtwice = false;
|
|
TopExp_Explorer ex;
|
|
for (ex.Init(FtospIN, TopAbs_EDGE); ex.More(); ex.Next())
|
|
{
|
|
// for (TopExp_Explorer ex(FtospIN,TopAbs_EDGE); ex.More(); ex.Next()){
|
|
const TopoDS_Shape& ee = ex.Current();
|
|
if (!BDS.HasShape(ee))
|
|
{
|
|
continue;
|
|
}
|
|
bool issp = myPB->IsSplit(ee, TopAbs_IN);
|
|
if (issp)
|
|
{
|
|
addtwice = !myPB->Splits(ee, TopAbs_IN).IsEmpty();
|
|
}
|
|
if (addtwice)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (addtwice)
|
|
{
|
|
neworiE = TopAbs::Complement(neworiE);
|
|
newE.Orientation(neworiE);
|
|
#ifdef OCCT_DEBUG
|
|
if (tEFOR)
|
|
debaddpwes(iFOR, TB1, iEG, neworiE, myPB, myPWES, "yap6 GFillON", "WES+ EspON ");
|
|
if (tE)
|
|
FUN_cout(newE);
|
|
#endif
|
|
myPWES->AddStartElement(newE);
|
|
}
|
|
return;
|
|
} // yap6
|
|
|
|
//=========================================
|
|
if (yap3)
|
|
{
|
|
#ifdef OCCT_DEBUG
|
|
if (tEFOR)
|
|
debfillonfemess(iFOR, iEG, myPB, myPWES, "yap3 GFillON");
|
|
if (tE)
|
|
{
|
|
std::cout << "yap3(FOR" << iFOR << " FCX" << iFCX << " EG" << GI << ") ";
|
|
std::cout << "TB1=";
|
|
TopAbs::Print(TB1, std::cout);
|
|
std::cout << " TB2=";
|
|
TopAbs::Print(TB2, std::cout);
|
|
std::cout << std::endl;
|
|
}
|
|
#endif
|
|
|
|
ie3d = ::FUN_findeSD(BDS, eON, EG, FOR, oe3d, 3);
|
|
if (ie3d == 0)
|
|
{
|
|
return;
|
|
}
|
|
const TopoDS_Edge& e3d = TopoDS::Edge(BDS.Shape(ie3d));
|
|
|
|
TopOpeBRepDS_Config cf;
|
|
bool cfok = FDS_Config3d(EspON, e3d, cf);
|
|
if (!cfok)
|
|
{
|
|
return;
|
|
}
|
|
|
|
TopAbs_Orientation oe3dk = oe3d;
|
|
// bool samegeom = ::TopOpeBRepBuild_FUN_aresamegeom(EG,e3d);
|
|
double parEG;
|
|
bool ok = FUN_tool_parE(eON, parON, EG, parEG, tolEG);
|
|
if (!ok)
|
|
{
|
|
return; // nyiRAISE
|
|
}
|
|
bool samegeom;
|
|
ok = FUN_tool_curvesSO(EG, parEG, e3d, samegeom);
|
|
if (!ok)
|
|
{
|
|
return; // nyiRAISE
|
|
}
|
|
if (!samegeom)
|
|
{
|
|
oe3dk = TopAbs::Complement(oe3dk);
|
|
}
|
|
|
|
bool keep3d = false;
|
|
// l'etat a construire sur FOR est TB1,
|
|
if (oe3dk == TopAbs_FORWARD)
|
|
{
|
|
keep3d = (TFEaft == TB1);
|
|
}
|
|
else if (oe3dk == TopAbs_REVERSED)
|
|
{
|
|
keep3d = (TFEbef == TB1);
|
|
}
|
|
else if (oe3dk == TopAbs_INTERNAL)
|
|
{
|
|
keep3d = true;
|
|
}
|
|
else if (oe3dk == TopAbs_EXTERNAL)
|
|
{
|
|
keep3d = false;
|
|
}
|
|
|
|
#ifdef OCCT_DEBUG
|
|
if (tEFOR)
|
|
{
|
|
std::cout << std::endl << "yap3 keep3d : " << keep3d << std::endl;
|
|
debfillonfemess3d(iFOR, iEG);
|
|
}
|
|
#endif
|
|
|
|
if (keep3d)
|
|
{
|
|
TopAbs_Orientation neworiE = oe3d;
|
|
if (cf == TopOpeBRepDS_DIFFORIENTED)
|
|
{
|
|
neworiE = TopAbs::Complement(neworiE);
|
|
}
|
|
TopoDS_Shape newE = EspON;
|
|
newE.Orientation(neworiE);
|
|
|
|
#ifdef OCCT_DEBUG
|
|
if (tEFOR)
|
|
debaddpwes(iFOR, TB1, iEG, neworiE, myPB, myPWES, "yap3 GFillON", "WES+ EspON ");
|
|
if (tE)
|
|
FUN_cout(newE);
|
|
#endif
|
|
myPWES->AddStartElement(newE);
|
|
}
|
|
|
|
return;
|
|
} // yap3
|
|
|
|
//=========================================
|
|
if (yap5)
|
|
{
|
|
#ifdef OCCT_DEBUG
|
|
if (tEFOR)
|
|
debfillonfemess(iFOR, iEG, myPB, myPWES, "yap5 GFillON");
|
|
if (tE)
|
|
{
|
|
std::cout << "yap5(FOR" << iFOR << " FCX" << iFCX << " EG" << GI << ") ";
|
|
std::cout << "TB1=";
|
|
TopAbs::Print(TB1, std::cout);
|
|
std::cout << " TB2=";
|
|
TopAbs::Print(TB2, std::cout);
|
|
std::cout << std::endl;
|
|
}
|
|
#endif
|
|
ie2d = ::FUN_findeSD(BDS, eON, EG, FOR, oe2d, 2);
|
|
if (ie2d == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
const TopoDS_Edge& e2d = TopoDS::Edge(BDS.Shape(ie2d));
|
|
TopOpeBRepDS_Config cf;
|
|
bool cfok = FDS_Config3d(EspON, e2d, cf);
|
|
if (!cfok)
|
|
{
|
|
return;
|
|
}
|
|
|
|
TopAbs_Orientation oe2dk = oe2d;
|
|
double parEG;
|
|
bool ok = FUN_tool_parE(eON, parON, EG, parEG, tolEG);
|
|
if (!ok)
|
|
{
|
|
return; // nyiRAISE
|
|
}
|
|
bool samegeom;
|
|
ok = FUN_tool_curvesSO(EG, parEG, e2d, samegeom);
|
|
if (!ok)
|
|
{
|
|
return; // nyiRAISE
|
|
}
|
|
if (!samegeom)
|
|
{
|
|
oe2dk = TopAbs::Complement(oe2dk);
|
|
}
|
|
|
|
bool keep2d = false;
|
|
// l'etat a construire sur FOR est TB1,
|
|
if (oe2dk == TopAbs_FORWARD)
|
|
{
|
|
keep2d = (TFEaft == TB1);
|
|
}
|
|
else if (oe2dk == TopAbs_REVERSED)
|
|
{
|
|
keep2d = (TFEbef == TB1);
|
|
}
|
|
else if (oe2dk == TopAbs_INTERNAL)
|
|
{
|
|
keep2d = true;
|
|
}
|
|
else if (oe2dk == TopAbs_EXTERNAL)
|
|
{
|
|
keep2d = false;
|
|
}
|
|
|
|
if (keep2d)
|
|
{
|
|
TopAbs_Orientation neworiE = oe2d;
|
|
if (cf == TopOpeBRepDS_DIFFORIENTED)
|
|
{
|
|
neworiE = TopAbs::Complement(neworiE);
|
|
}
|
|
TopoDS_Shape newE = EspON;
|
|
newE.Orientation(neworiE);
|
|
|
|
#ifdef OCCT_DEBUG
|
|
if (tEFOR)
|
|
debaddpwes(iFOR, TB1, iEG, neworiE, myPB, myPWES, "yap5 GFillON", "WES+ EspON ");
|
|
if (tE)
|
|
FUN_cout(newE);
|
|
#endif
|
|
myPWES->AddStartElement(newE);
|
|
}
|
|
|
|
return;
|
|
} // yap5
|
|
|
|
//=========================================
|
|
if (yap4)
|
|
{
|
|
#ifdef OCCT_DEBUG
|
|
if (tEFOR)
|
|
debfillonfemess(iFOR, iEG, myPB, myPWES, "yap4 GFillON");
|
|
if (tE)
|
|
{
|
|
std::cout << "yap4(FOR" << iFOR << " FCX" << iFCX << " EG" << GI << ") ";
|
|
std::cout << "TB1=";
|
|
TopAbs::Print(TB1, std::cout);
|
|
std::cout << " TB2=";
|
|
TopAbs::Print(TB2, std::cout);
|
|
std::cout << std::endl;
|
|
}
|
|
#endif
|
|
|
|
TopAbs_Orientation oTFE = TFE.Orientation(TB1);
|
|
|
|
TopAbs_Orientation neworiE = oTFE;
|
|
TopoDS_Shape newE = EspON;
|
|
newE.Orientation(neworiE);
|
|
#ifdef OCCT_DEBUG
|
|
if (tEFOR)
|
|
debaddpwes(iFOR, TB1, iEG, neworiE, myPB, myPWES, "yap4 GFillON", "WES+ EspON ");
|
|
if (tE)
|
|
FUN_cout(newE);
|
|
#endif
|
|
myPWES->AddStartElement(newE);
|
|
|
|
return;
|
|
} // yap4
|
|
|
|
//=========================================
|
|
if (yap7)
|
|
{
|
|
// xpu290598 : CTS20212
|
|
#ifdef OCCT_DEBUG
|
|
if (tEFOR)
|
|
debfillonfemess(iFOR, iEG, myPB, myPWES, "yap7 GFillON");
|
|
if (tE)
|
|
{
|
|
std::cout << "yap7(FOR" << iFOR << " FCX" << iFCX << " EG" << GI << ") ";
|
|
std::cout << "TB1=";
|
|
TopAbs::Print(TB1, std::cout);
|
|
std::cout << " TB2=";
|
|
TopAbs::Print(TB2, std::cout);
|
|
std::cout << std::endl;
|
|
}
|
|
#endif
|
|
bool isbound = false;
|
|
for (NCollection_List<TopoDS_Shape>::Iterator it(BDS.ShapeSameDomain(iFOR)); it.More();
|
|
it.Next())
|
|
{
|
|
TopExp_Explorer ex(it.Value(), TopAbs_EDGE);
|
|
for (; ex.More(); ex.Next())
|
|
{
|
|
const TopoDS_Shape& E = ex.Current();
|
|
if (E.IsSame(EG))
|
|
{
|
|
isbound = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
TopAbs_Orientation oTFE = TFE.Orientation(TB1);
|
|
TopAbs_Orientation neworiE = oTFE;
|
|
|
|
if (ComOfCut)
|
|
{ // CTS20212 : tspIN(f7),tspON(e4)
|
|
if (!EGBoundFOR)
|
|
{
|
|
if (!isbound)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// CTS20212 : tspIN(f7),tspON(e5)
|
|
bool samegeomref = false;
|
|
if (FORisref)
|
|
{
|
|
samegeomref = true;
|
|
}
|
|
else
|
|
{
|
|
samegeomref = (cFOR == TopOpeBRepDS_SAMEORIENTED);
|
|
if (oFOR != orefFOR)
|
|
{
|
|
samegeomref = !samegeomref;
|
|
}
|
|
}
|
|
if (!samegeomref)
|
|
{
|
|
neworiE = TopAbs::Complement(neworiE);
|
|
}
|
|
|
|
TopoDS_Shape newE = EspON;
|
|
newE.Orientation(neworiE);
|
|
#ifdef OCCT_DEBUG
|
|
if (tEFOR)
|
|
debaddpwes(iFOR, TB1, iEG, neworiE, myPB, myPWES, "yap7 GFillON", "WES+ EspON ");
|
|
if (tE)
|
|
FUN_cout(newE);
|
|
#endif
|
|
myPWES->AddStartElement(newE);
|
|
|
|
return;
|
|
} // yap7
|
|
|
|
} // GFillONPartsWES2
|