Loading files
// Created on: 1994-02-17
// Created by: Jean Yves LEBEY
// Copyright (c) 1994-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 <BndLib_Add3dCurve.hxx>
#include <BRep_Tool.hxx>
#include <BRepTools.hxx>
#include <gp_Pnt.hxx>
#include <Precision.hxx>
#include <Standard_CString.hxx>
#include <Standard_Integer.hxx>
#include <NCollection_List.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Shape.hxx>
#include <TopOpeBRep_FacesFiller.hxx>
#include <TopOpeBRep_FacesIntersector.hxx>
#include <TopOpeBRep_FFTransitionTool.hxx>
#include <TopOpeBRep_GeomTool.hxx>
#include <TopOpeBRep_LineInter.hxx>
#include <TopOpeBRep_PointGeomTool.hxx>
#include <TopOpeBRep_VPointInter.hxx>
#include <TopOpeBRep_VPointInterIterator.hxx>
#include <TopOpeBRepDS_Interference.hxx>
#include <TopOpeBRepDS_InterferenceTool.hxx>
#include <TopOpeBRepDS_ProcessInterferencesTool.hxx>
#include <TopOpeBRepDS_Transition.hxx>
#include <TopOpeBRepTool_GEOMETRY.hxx>
#include <TopOpeBRepTool_PROJECT.hxx>
#include <TopOpeBRepTool_TOPOLOGY.hxx>
#include <TopOpeBRepTool_makeTransition.hxx>
#include <TopOpeBRepTool_TOOL.hxx>
#ifdef OCCT_DEBUG
Standard_EXPORT void debrest(const int i)
{
std::cout << "+ debrest " << i << std::endl;
}
Standard_EXPORT void debrline()
{
std::cout << "+ debrline" << std::endl;
}
static void FUN_traceRLine(const TopOpeBRep_LineInter&) {}
static void FUN_traceGLine(const TopOpeBRep_LineInter&) {}
#endif
#define M_FORWARD(o) (o == TopAbs_FORWARD)
#define M_REVERSED(o) (o == TopAbs_REVERSED)
#define FORWARD (1)
#define REVERSED (2)
#define INTERNAL (3)
#define EXTERNAL (4)
#define CLOSING (5)
Standard_EXPORT void FUN_GetdgData(
TopOpeBRepDS_DataStructure*& pDS,
const TopOpeBRep_LineInter& L,
const TopoDS_Face& F1,
const TopoDS_Face& F2,
NCollection_DataMap<TopoDS_Shape, NCollection_List<TopoDS_Shape>, TopTools_ShapeMapHasher>&
datamap);
Standard_EXPORT void FUN_FillVof12(const TopOpeBRep_LineInter& L, TopOpeBRepDS_DataStructure* pDS);
#define M_FINDVP (0) // only look for new vp
#define M_MKNEWVP (1) // only make newvp
#define M_GETVP (2) // steps (0) [+(1) if (O) fails]
Standard_EXPORT void FUN_VPIndex(
TopOpeBRep_FacesFiller& FF,
const TopOpeBRep_LineInter& L,
const TopOpeBRep_VPointInter& VP,
const int ShapeIndex,
const occ::handle<TopOpeBRepDS_HDataStructure>& HDS,
const NCollection_List<occ::handle<TopOpeBRepDS_Interference>>& DSCIL,
TopOpeBRepDS_Kind& PVKind,
int& PVIndex, // out
bool& EPIfound,
occ::handle<TopOpeBRepDS_Interference>& IEPI, // out
bool& CPIfound,
occ::handle<TopOpeBRepDS_Interference>& ICPI, // out
const int mkVP);
Standard_EXPORT bool FUN_newtransEdge(const occ::handle<TopOpeBRepDS_HDataStructure>& HDS,
const TopOpeBRep_FacesFiller& FF,
const TopOpeBRep_LineInter& L,
const bool& Lonrest,
const TopOpeBRep_VPointInter& VP,
const TopOpeBRepDS_Kind PVKind,
const int PVIndex,
const int& OOShapeIndex,
const TopoDS_Edge& edge,
const NCollection_List<TopoDS_Shape>& ERL,
TopOpeBRepDS_Transition& T);
#define M_INTERNAL(st) (st == TopAbs_INTERNAL)
//=======================================================================
// 3D
// purpose : The compute of a transition edge/face given interferences
// attached to the edge (stored in the DS).
//=======================================================================
//=================================================================================================
void TopOpeBRep_FacesFiller::ProcessLine()
{
bool reject = (!myLineOK || myLine == nullptr);
if (reject)
{
return;
}
ResetDSC();
bool HasVPonR = myLine->HasVPonR();
if (HasVPonR)
{
FillLineVPonR();
}
else
{
FillLine();
}
bool inl = myLine->INL();
if (inl)
{
return;
}
myHDS->SortOnParameter(myDSCIL);
AddShapesLine();
}
//=================================================================================================
void TopOpeBRep_FacesFiller::ResetDSC()
{
myDSCIndex = 0;
myDSCIL.Clear();
myCurrentLine = nullptr;
myMapOfTreatedVertexListOfEdge.Clear();
myLastVPind = 0;
}
//=================================================================================================
void TopOpeBRep_FacesFiller::ProcessVPInotonR(TopOpeBRep_VPointInterIterator& VPI)
{
const TopOpeBRep_VPointInter& VP = VPI.CurrentVP();
ProcessVPnotonR(VP);
}
//=================================================================================================
void TopOpeBRep_FacesFiller::ProcessVPnotonR(const TopOpeBRep_VPointInter& VP)
{
int ShapeIndex = 0;
int iVP = VP.Index();
int iINON1, iINONn, nINON;
myLine->VPBounds(iINON1, iINONn, nINON);
NCollection_List<occ::handle<TopOpeBRepDS_Interference>>::Iterator itCPIL(myDSCIL);
TopOpeBRepDS_Kind PVKind;
int PVIndex;
bool CPIfound = GetGeometry(itCPIL, VP, PVIndex, PVKind);
if (!CPIfound)
{
if (iVP != iINON1 && iVP != iINONn)
{
#ifdef OCCT_DEBUG
std::cout << "VP " << iVP << " on " << 0 << " : point d'intersection anormal : rejet"
<< std::endl;
#endif
return;
}
}
if (!CPIfound)
{
bool found = GetFFGeometry(VP, PVKind, PVIndex);
if (!found)
{
PVIndex = MakeGeometry(VP, ShapeIndex, PVKind);
}
}
TopOpeBRepDS_Transition transLine;
if (CPIfound)
{
const occ::handle<TopOpeBRepDS_Interference>& I = itCPIL.Value();
const TopOpeBRepDS_Transition& TI = I->Transition();
transLine = TI.Complement();
}
else
{
if (iVP == iINON1)
{
transLine.Set(TopAbs_FORWARD);
}
else if (iVP == iINONn)
{
transLine.Set(TopAbs_REVERSED);
}
}
double parline = VP.ParameterOnLine();
occ::handle<TopOpeBRepDS_Interference> CPI =
TopOpeBRepDS_InterferenceTool::MakeCurveInterference(transLine,
TopOpeBRepDS_CURVE,
0,
PVKind,
PVIndex,
parline);
StoreCurveInterference(CPI);
} // ProcessVPnotonR
//=================================================================================================
void TopOpeBRep_FacesFiller::ProcessVPR(TopOpeBRep_FacesFiller& FF,
const TopOpeBRep_VPointInter& VP)
{
TopOpeBRepDS_Transition LineTonF1 = FaceFaceTransition(1);
TopOpeBRepDS_Transition LineTonF2 = FaceFaceTransition(2);
TopoDS_Face F1 = myF1;
TopoDS_Face F2 = myF2;
// --- check interiority of VPoint to the restrictions
bool tokeep = VP.Keep();
if (!tokeep)
{
return;
}
int ShapeIndex = VP.ShapeIndex();
if (ShapeIndex == 0)
{
FF.ProcessVPnotonR(VP);
}
else if (ShapeIndex == 1)
{
FF.ProcessVPonR(VP, LineTonF1, F1, 1);
}
else if (ShapeIndex == 2)
{
FF.ProcessVPonR(VP, LineTonF2, F2, 2);
}
else if (ShapeIndex == 3)
{
bool isV1 = VP.IsVertexOnS1();
bool isV2 = VP.IsVertexOnS2();
int shin1 = 1;
if (isV2 && !isV1)
{
shin1 = 2;
}
if (shin1 == 1)
{
FF.ProcessVPonR(VP, LineTonF1, F1, 1);
FF.ProcessVPonR(VP, LineTonF2, F2, 2);
}
else if (shin1 == 2)
{
FF.ProcessVPonR(VP, LineTonF2, F2, 2);
FF.ProcessVPonR(VP, LineTonF1, F1, 1);
}
}
} // FUNvponr
static bool FUN_brep_ONfirstP(const TopOpeBRep_VPointInter& vpf, const TopOpeBRep_VPointInter& VP)
// prequesitory : gline is on edge
{
double parfirst = vpf.ParameterOnLine();
double parcur = VP.ParameterOnLine();
double d = parcur - parfirst;
double tol = Precision::Confusion(); // nyixpu051098 : see lbr...
bool ONfirstP = (std::abs(d) < tol);
return ONfirstP;
}
//=================================================================================================
void TopOpeBRep_FacesFiller::ProcessRLine()
{
if (myLine->TypeLineCurve() != TopOpeBRep_RESTRICTION)
{
return;
}
bool addIFE = true;
if (!addIFE)
{
return;
}
const TopoDS_Edge& Erest = TopoDS::Edge(myLine->Arc());
bool FIisrest = myFacesIntersector->IsRestriction(Erest);
if (!FIisrest)
{
return;
}
bool isedge1 = myLine->ArcIsEdge(1);
bool isedge2 = myLine->ArcIsEdge(2);
int EShapeIndex = (isedge1) ? 1 : (isedge2) ? 2 : 0;
int iErest = myDS->AddShape(Erest, EShapeIndex);
int rank = myDS->AncestorRank(iErest);
int OOrank = (rank == 1) ? 2 : 1;
int iF1 = myDS->AddShape(myF1, 1);
int iF2 = myDS->AddShape(myF2, 2);
occ::handle<TopOpeBRepDS_Interference> IFE;
TopOpeBRepDS_Transition T1 = FaceFaceTransition(1);
T1.Index(iF2);
TopOpeBRepDS_Transition T2 = FaceFaceTransition(2);
T2.Index(iF1);
IFE = TopOpeBRepDS_InterferenceTool::MakeFaceEdgeInterference(T1,
iF2,
iErest,
isedge1,
TopOpeBRepDS_UNSHGEOMETRY);
myHDS->StoreInterference(IFE, iF1);
IFE = TopOpeBRepDS_InterferenceTool::MakeFaceEdgeInterference(T2,
iF1,
iErest,
isedge2,
TopOpeBRepDS_UNSHGEOMETRY);
myHDS->StoreInterference(IFE, iF2);
// #################### Rline Processing ####################
// xpu061098
TopOpeBRep_VPointInterIterator VPI;
VPI.Init((*myLine));
double tola = Precision::Angular() * 1.e5; // NYIXPUTOL
const TopOpeBRep_VPointInter& vpf = VPI.CurrentVP();
for (; VPI.More(); VPI.Next())
{
const TopOpeBRep_VPointInter& VP = VPI.CurrentVP();
int absindex = VP.ShapeIndex(); // 0,1,2,3
double parRest;
bool okR = VP.ParonE(Erest, parRest);
if (!okR)
{
parRest = VP.ParameterOnLine();
}
bool on2edges = (absindex == 3) || (absindex == OOrank);
if (!on2edges)
{
// MSV: treat the case when an edge is touched by interior of a face
// MSV: the commented code below leads to exception on 1cto 025 H3
// (object and tool have same subshapes), so to enable it
// the debug is needed
// bool SIisvertex = VP.IsVertex(EShapeIndex);
// if (SIisvertex) continue;
// int ShapeIndex = EShapeIndex;
// int OOShapeIndex = (ShapeIndex == 1) ? 2 : 1;
// TopoDS_Face OOFace = (*this).Face(OOShapeIndex);
// int iOOFace = myDS->Shape(OOFace);
// // make PVIndex
// TopOpeBRepDS_Kind PVKind = TopOpeBRepDS_POINT;
// int PVIndex = 0;
// bool EPIfound=false,CPIfound=false;
// occ::handle<TopOpeBRepDS_Interference> IEPI,ICPI;
// FUN_VPIndex((*this),(*myLine),VP,ShapeIndex,myHDS,myDSCIL,
// PVKind,PVIndex,EPIfound,IEPI,CPIfound,ICPI,
// M_GETVP);
// bool Efound = (EPIfound || CPIfound);
// bool Ifound = (PVIndex != 0);
// bool condmake = (!Efound && !Ifound);
// if (condmake)
// PVIndex = MakeGeometry(VP,ShapeIndex,PVKind);
// // make transition on edge
// TopOpeBRepDS_Transition transEdge;
// TopOpeBRepDS_Transition Trans = FaceFaceTransition(ShapeIndex);
// bool TransUNK = Trans.IsUnknown();
// if (!TransUNK) {
// TopAbs_Orientation oriErest = Erest.Orientation();
// transEdge =
// TopOpeBRep_FFTransitionTool::ProcessLineTransition(VP,ShapeIndex,oriErest);
// TransUNK = FDS_hasUNK(transEdge);
// }
// if (TransUNK) {
// bool ONfirstP = ::FUN_brep_ONfirstP(vpf,VP);
// TopAbs_Orientation OVP = ONfirstP ? TopAbs_FORWARD : TopAbs_REVERSED;
// transEdge.Set(OVP);
// if (ONfirstP) transEdge.StateAfter(TopAbs_ON);
// else transEdge.StateBefore(TopAbs_ON);
// TransUNK = FDS_hasUNK(transEdge);
// }
// if (TransUNK) continue;
// // see if there is already such interference in DS
// TopAbs_Orientation otransEdge = transEdge.Orientation(TopAbs_IN);
// const NCollection_List<occ::handle<TopOpeBRepDS_Interference>>& lIedge =
// myHDS->DS().ShapeInterferences(Erest);
// NCollection_List<occ::handle<TopOpeBRepDS_Interference>> copy;
// FDS_copy(lIedge,copy); NCollection_List<occ::handle<TopOpeBRepDS_Interference>>
// l1,l2; int nfound = FUN_selectGIinterference(copy,PVIndex,l1); if (nfound) {
// if (iOOFace != 0) {
// NCollection_List<occ::handle<TopOpeBRepDS_Interference>> l3,l4;
// nfound = FUN_selectITRASHAinterference(l2,iOOFace,l3);
// if (nfound != 0) nfound = FUN_selectTRAORIinterference(l3,otransEdge,l4);
// if (nfound) continue;
// }
// }
// // make and store interference
// occ::handle<TopOpeBRepDS_Interference> EPIf;
// if (iOOFace == 0) iOOFace = myDS->AddShape(OOFace,OOShapeIndex);
// TopOpeBRepDS_Transition T = transEdge; T.Index(iOOFace);
// EPIf = MakeEPVInterference(T,iOOFace,PVIndex,parRest,PVKind,
// TopOpeBRepDS_FACE,SIisvertex);
// myHDS->StoreInterference(EPIf,Erest);
continue;
}
TopoDS_Edge OOE = TopoDS::Edge(VP.Edge(OOrank));
int iOO = myDS->AddShape(OOE, OOrank);
double OOpar;
VP.ParonE(OOE, OOpar);
// xpu091198 : 1d interf done in EdgesFiller processing (cto cylcong *)
bool sdmeds = FUN_ds_sdm((*myDS), Erest, OOE);
if (sdmeds)
{
continue;
}
// clang-format off
int obRest = TopOpeBRepTool_TOOL::OnBoundary(parRest,Erest); //vertex can be missed
int obOO = TopOpeBRepTool_TOOL::OnBoundary(OOpar,OOE); //vertex can be missed
// clang-format on
if ((obRest == EXTERNAL) || (obOO == EXTERNAL))
{
#ifdef OCCT_DEBUG
if (obRest == EXTERNAL)
std::cout << "***********ProcessRLine : faulty parameter on Erest" << std::endl;
if (obOO == EXTERNAL)
std::cout << "***********ProcessRLine : faulty parameter on OOE" << std::endl;
#endif
}
bool tgeds = FUN_tool_EtgOOE(parRest, Erest, OOpar, OOE, tola);
// clang-format off
TopOpeBRepDS_Kind PVKind = TopOpeBRepDS_POINT; int PVIndex = 0; // POINT or VERTEX index
// clang-format on
for (int ShapeIndex = 1; ShapeIndex <= 2; ShapeIndex++)
{
int OOShapeIndex = (ShapeIndex == 1) ? 2 : 1;
bool SIErest = (ShapeIndex == rank);
bool SIisvertex = VP.IsVertex(ShapeIndex);
bool OOisvertex = VP.IsVertex(OOShapeIndex);
TopoDS_Face OOFace = (*this).Face(OOShapeIndex);
int iOOFace = myDS->Shape(OOFace);
TopoDS_Edge edge, OOedge;
int OOedgeIndex;
double paredge;
int onbound;
if (SIErest)
{
edge = Erest;
paredge = parRest;
onbound = obRest;
OOedge = OOE;
OOedgeIndex = iOO;
}
else
{
OOedge = Erest;
OOedgeIndex = iErest;
onbound = obOO;
edge = OOE;
paredge = OOpar;
}
// PVIndex :
// --------
// xpu150399 : BUC60382
bool EPIfound = false, CPIfound = false;
occ::handle<TopOpeBRepDS_Interference> IEPI, ICPI;
ProcessVPondgE(VP,
ShapeIndex,
PVKind,
PVIndex, // out
EPIfound,
IEPI, // out
CPIfound,
ICPI); // out
if (PVIndex == 0)
{
// bool EPIfound=false,CPIfound=false;
// occ::handle<TopOpeBRepDS_Interference> IEPI,ICPI;
FUN_VPIndex((*this),
(*myLine),
VP,
ShapeIndex,
myHDS,
myDSCIL,
PVKind,
PVIndex,
EPIfound,
IEPI,
CPIfound,
ICPI,
M_GETVP);
bool Efound = (EPIfound || CPIfound);
bool Ifound = (PVIndex != 0);
bool condmake = (!Efound && !Ifound);
if (condmake)
{
if (SIisvertex)
{
PVIndex = MakeGeometry(VP, ShapeIndex, PVKind);
}
else if (OOisvertex)
{
PVIndex = MakeGeometry(VP, OOShapeIndex, PVKind);
}
else
{
PVIndex = MakeGeometry(VP, ShapeIndex, PVKind);
}
}
}
// transEdge :
// ----------
if (OOedgeIndex == 0)
{
OOedgeIndex = myDS->AddShape(OOedge, OOShapeIndex);
}
const TopOpeBRepDS_Transition& llt1 = FaceFaceTransition(1);
const TopOpeBRepDS_Transition& llt2 = FaceFaceTransition(2);
TopOpeBRepDS_Transition Trans = (ShapeIndex == 1) ? llt1 : llt2;
bool TransUNK = Trans.IsUnknown();
TopOpeBRepDS_Transition transEdge;
bool Tunk = true;
if (!TransUNK)
{ // xpu281098 PRO12875(edge9,OOface11)
if ((absindex == ShapeIndex) || (absindex == 3))
{
if (SIErest)
{
// transition on Erest at VP / OOface = transition at VP on Line restriction
TopAbs_Orientation oriErest = Erest.Orientation();
transEdge =
TopOpeBRep_FFTransitionTool::ProcessLineTransition(VP, ShapeIndex, oriErest);
if (((onbound == 1) || (onbound == 2)) && tgeds) // xpu290399 : edge is restriction,
// edge15,OOedge14,OOface13
{
transEdge.Before(TopAbs_UNKNOWN);
transEdge.After(TopAbs_UNKNOWN);
}
}
else
{
// transition on edge at VP / OOface ?=
// TopOpeBRep_FFTransitionTool::ProcessEdgeTransition(VP,ShapeIndex,Transori);
// nyi
}
}
Tunk = FDS_hasUNK(transEdge);
}
if (Tunk)
{
if (SIErest)
{
// As edge=Erest is on OOFace, we only compute 2d interferences
bool ONfirstP = ::FUN_brep_ONfirstP(vpf, VP);
TopAbs_Orientation OVP = ONfirstP ? TopAbs_FORWARD : TopAbs_REVERSED;
TopAbs_Orientation oOO;
bool ok = FUN_tool_orientEinFFORWARD(OOedge, OOFace, oOO);
if (!ok)
{
continue;
}
if (M_INTERNAL(oOO))
{
OVP = TopAbs_INTERNAL;
}
// xpu240399 : cto015I2 (e15,v16)
// edge and OOedge are tangent, we do not keep the orientation
if (!tgeds)
{
transEdge.Set(OVP);
}
}
else
{
TopOpeBRepDS_Transition Tr;
bool ok = FUN_newtransEdge(myHDS,
(*this),
(*myLine),
myLineIsonEdge,
VP,
PVKind,
PVIndex,
OOShapeIndex,
edge,
myERL,
Tr);
if (!ok)
{
continue;
}
transEdge.Before(Tr.Before());
transEdge.After(Tr.After());
}
} // Tunk
Tunk = FDS_hasUNK(transEdge);
if (Tunk)
{
continue;
}
TopAbs_Orientation otransEdge = transEdge.Orientation(TopAbs_IN);
const NCollection_List<occ::handle<TopOpeBRepDS_Interference>>& lIedge =
myHDS->DS().ShapeInterferences(edge);
NCollection_List<occ::handle<TopOpeBRepDS_Interference>> copy;
FDS_copy(lIedge, copy);
NCollection_List<occ::handle<TopOpeBRepDS_Interference>> l1, l2;
int nfound = FUN_selectGIinterference(copy, PVIndex, l1);
if (OOedgeIndex != 0)
{
nfound = FUN_selectSIinterference(l1, OOedgeIndex, l2);
}
if (nfound)
{
if (sdmeds)
{
NCollection_List<occ::handle<TopOpeBRepDS_Interference>> l3, l4;
nfound = FUN_selectITRASHAinterference(l2, OOedgeIndex, l3);
if (nfound != 0)
{
nfound = FUN_selectTRAORIinterference(l3, otransEdge, l4);
}
if (nfound)
{
continue; // has I1d=(transEdge(OOedgeIndex),PVIndex,OOedgeIndex);
}
}
else if (iOOFace != 0)
{
NCollection_List<occ::handle<TopOpeBRepDS_Interference>> l3, l4;
nfound = FUN_selectITRASHAinterference(l2, iOOFace, l3);
if (nfound != 0)
{
nfound = FUN_selectTRAORIinterference(l3, otransEdge, l4);
}
if (nfound)
{
continue; // has I2d=(transEdge(iOOFace),PVIndex,OOedgeIndex)
}
}
} // nfound
// EPI :
// ----
occ::handle<TopOpeBRepDS_Interference> EPI;
{
if (iOOFace == 0)
{
iOOFace = myDS->AddShape(OOFace, OOShapeIndex);
}
TopOpeBRepDS_Transition T = transEdge;
T.Index(iOOFace);
EPI = MakeEPVInterference(T, OOedgeIndex, PVIndex, paredge, PVKind, SIisvertex);
}
myHDS->StoreInterference(EPI, edge);
// EPIf :
// -----
if (!SIErest)
{
occ::handle<TopOpeBRepDS_Interference> EPIf;
TopOpeBRepDS_Transition T = transEdge;
T.Index(iOOFace);
EPIf =
MakeEPVInterference(T, iOOFace, PVIndex, paredge, PVKind, TopOpeBRepDS_FACE, SIisvertex);
myHDS->StoreInterference(EPIf, edge);
}
} // ShapeIndex=1..2
} // VPI
// ####################
}
static bool FUN_haslastvpon0(const TopOpeBRep_LineInter& L)
{
const bool wline = (L.TypeLineCurve() == TopOpeBRep_WALKING);
if (!wline)
{
return false;
}
int iINON1, iINONn, nINON;
L.VPBounds(iINON1, iINONn, nINON);
TopOpeBRep_VPointInterIterator VPI;
VPI.Init(L);
for (; VPI.More(); VPI.Next())
{
const TopOpeBRep_VPointInter& VP = VPI.CurrentVP();
const int absindex = VP.ShapeIndex();
const int iVP = VP.Index();
if (iVP == iINONn && absindex == 0)
{
return true;
}
}
return false;
}
//=================================================================================================
void TopOpeBRep_FacesFiller::FillLineVPonR()
{
#ifdef OCCT_DEBUG
bool trline = false;
#endif
// if a VP is on degenerated edge, adds the triplet
// (vertex, closing edge, degenerated edge) to the
// map as vertex for key.
// myDataforDegenEd.Clear();
FUN_GetdgData(myDS, (*myLine), myF1, myF2, myDataforDegenEd);
FUN_FillVof12((*myLine), myDS);
mykeptVPnbr = 0;
if (myLine->TypeLineCurve() == TopOpeBRep_RESTRICTION)
{
#ifdef OCCT_DEBUG
if (trline)
FUN_traceRLine(*myLine);
#endif
ProcessRLine();
return;
}
int iINON1, iINONn, nINON;
myLine->VPBounds(iINON1, iINONn, nINON);
if (nINON == 0)
{
return;
}
#ifdef OCCT_DEBUG
if (trline)
FUN_traceGLine(*myLine);
#endif
myLineIsonEdge = LSameDomainERL(*myLine, myERL);
// walking (case mouch1a 1 1) : line (vpfirst on 3,vplast on 0,nvpkept = 2) => kept
myLastVPison0 = ::FUN_haslastvpon0(*myLine);
//---------------------------------------------------------------------- // IMPORTANT :
// Some of Curve/Point transitions for vpoints keep on RESTRICTION lines
// sharing same domain with the current geometric line are computed here
//----------------------------------------------------------------------
#ifdef OCCT_DEBUG
#endif
TopOpeBRep_VPointInterIterator VPI;
VPI.Init((*myLine));
for (; VPI.More(); VPI.Next())
{
const TopOpeBRep_VPointInter& VP = VPI.CurrentVP();
ProcessVPR((*this), VP);
}
if (myLineIsonEdge && (!myDSCIL.IsEmpty()))
{
myDSCIL.Clear();
}
}
//=================================================================================================
void TopOpeBRep_FacesFiller::FillLine()
{
int iINON1, iINONn, nINON;
myLine->VPBounds(iINON1, iINONn, nINON);
if (nINON == 0)
{
return;
}
int ShapeIndex = 0;
occ::handle<TopOpeBRepDS_Interference> CPI;
TopOpeBRep_VPointInterIterator VPI;
for (VPI.Init((*myLine)); VPI.More(); VPI.Next())
{
const TopOpeBRep_VPointInter& VP = VPI.CurrentVP();
if (!VP.Keep())
{
continue;
}
int PVIndex;
TopOpeBRepDS_Kind PVKind;
NCollection_List<occ::handle<TopOpeBRepDS_Interference>>::Iterator itCPIL(myDSCIL);
bool CPIfound;
CPIfound = GetGeometry(itCPIL, VP, PVIndex, PVKind);
if (!CPIfound)
{
bool found = GetFFGeometry(VP, PVKind, PVIndex);
if (!found)
{
PVIndex = MakeGeometry(VP, ShapeIndex, PVKind);
}
}
TopOpeBRepDS_Transition transLine;
if (!CPIfound)
{
int iVP = VPI.CurrentVPIndex();
if (iVP == iINON1)
{
transLine.Set(TopAbs_FORWARD);
}
else if (iVP == iINONn)
{
transLine.Set(TopAbs_REVERSED);
}
}
else
{
transLine = itCPIL.Value()->Transition().Complement();
}
double parline = VPI.CurrentVP().ParameterOnLine();
CPI = TopOpeBRepDS_InterferenceTool::MakeCurveInterference(transLine,
TopOpeBRepDS_CURVE,
0,
PVKind,
PVIndex,
parline);
StoreCurveInterference(CPI);
} // loop on VPoints
} // FillLine
//=================================================================================================
void TopOpeBRep_FacesFiller::AddShapesLine()
{
bool dscilemp = myDSCIL.IsEmpty();
if (dscilemp)
{
return;
}
bool inl = myLine->INL();
if (inl)
{
return;
}
TopOpeBRepDS_Curve& DSC = myDS->ChangeCurve(myDSCIndex);
occ::handle<Geom_Curve> C3D;
occ::handle<Geom2d_Curve> PC1, PC2;
occ::handle<TopOpeBRepDS_Interference> FCI1, FCI2;
int iF1 = myDS->AddShape(myF1, 1);
int iF2 = myDS->AddShape(myF2, 2);
double pmin, pmax;
myHDS->MinMaxOnParameter(myDSCIL, pmin, pmax);
double d = std::abs(pmin - pmax);
bool id = (d <= Precision::PConfusion());
bool isper = myLine->IsPeriodic();
id = (id && !isper);
bool wline = (myLine->TypeLineCurve() == TopOpeBRep_WALKING);
bool vclosed = myLine->IsVClosed();
if (wline && !isper && vclosed)
{
// xpu240399 : USA60298 : avoid creating curve
// MSV: take into account that geometry can be of type VERTEX
int ipf = myDSCIL.First()->Geometry();
TopOpeBRepDS_Kind kpf = myDSCIL.First()->GeometryType();
gp_Pnt ptf;
double tol, tolf, toll;
if (kpf == TopOpeBRepDS_POINT)
{
TopOpeBRepDS_Point pf = myDS->Point(ipf);
ptf = pf.Point();
tolf = pf.Tolerance();
}
else
{ // VERTEX
TopoDS_Vertex vf = TopoDS::Vertex(myDS->Shape(ipf));
ptf = BRep_Tool::Pnt(vf);
tolf = BRep_Tool::Tolerance(vf);
}
int ipl = myDSCIL.Last()->Geometry();
TopOpeBRepDS_Kind kpl = myDSCIL.Last()->GeometryType();
if (kpl == TopOpeBRepDS_POINT)
{
TopOpeBRepDS_Point pl = myDS->Point(ipl);
toll = pl.Tolerance();
}
else
{ // VERTEX
TopoDS_Vertex vl = TopoDS::Vertex(myDS->Shape(ipl));
toll = BRep_Tool::Tolerance(vl);
}
tol = std::max(tolf, toll);
bool onsampt = true;
for (int ii = 1; ii <= myLine->NbWPoint(); ii++)
{
TopOpeBRep_WPointInter wp = myLine->WPoint(ii);
gp_Pnt pp = wp.Value();
if (!pp.IsEqual(ptf, tol))
{
onsampt = false;
break;
}
}
if (onsampt)
{
id = true;
}
}
if (id)
{
DSC.ChangeKeep(false);
return;
}
TopOpeBRep_GeomTool::MakeCurves(pmin, pmax, (*myLine), myF1, myF2, DSC, PC1, PC2);
// Patch: avoid making too small edges. Made for the bug buc60926 by jgv, 14.06.01.
double fpar, lpar;
DSC.Range(fpar, lpar);
GeomAdaptor_Curve theCurve(DSC.Curve(), fpar, lpar);
Bnd_Box theBox;
BndLib_Add3dCurve::Add(theCurve, 0., theBox);
double Xmin, Ymin, Zmin, Xmax, Ymax, Zmax, MaxSide;
theBox.Get(Xmin, Ymin, Zmin, Xmax, Ymax, Zmax);
MaxSide = std::max(std::max(Xmax - Xmin, Ymax - Ymin), Zmax - Zmin);
double MinTol = std::min(BRep_Tool::Tolerance(myF1), BRep_Tool::Tolerance(myF2));
if (MaxSide < MinTol)
{
DSC.ChangeKeep(false);
return;
}
double tolDSC = 1.e-8;
DSC.Tolerance(tolDSC);
const TopOpeBRepDS_Transition& lllt1 = FaceFaceTransition(1);
const TopOpeBRepDS_Transition& lllt2 = FaceFaceTransition(2);
myDS->ChangeCurveInterferences(myDSCIndex).Append(myDSCIL);
{
TopOpeBRepDS_Transition T1 = lllt1;
T1.Index(iF2);
FCI1 = TopOpeBRepDS_InterferenceTool::MakeFaceCurveInterference(T1, iF2, myDSCIndex, PC1);
myHDS->StoreInterference(FCI1, myF1);
}
{
TopOpeBRepDS_Transition T2 = lllt2;
T2.Index(iF1);
FCI2 = TopOpeBRepDS_InterferenceTool::MakeFaceCurveInterference(T2, iF1, myDSCIndex, PC2);
myHDS->StoreInterference(FCI2, myF2);
}
DSC.SetShapes(myF1, myF2);
DSC.SetSCI(FCI1, FCI2);
}
//=================================================================================================
void TopOpeBRep_FacesFiller::StoreCurveInterference(const occ::handle<TopOpeBRepDS_Interference>& I)
{
if (myDSCIndex == 0)
{
TopOpeBRepDS_Curve DSC;
myDSCIndex = myDS->AddCurve(DSC);
}
I->Support(myDSCIndex);
myHDS->StoreInterference(I, myDSCIL);
}
//=================================================================================================
bool TopOpeBRep_FacesFiller::GetGeometry(
NCollection_List<occ::handle<TopOpeBRepDS_Interference>>::Iterator& IT,
const TopOpeBRep_VPointInter& VP,
int& G,
TopOpeBRepDS_Kind& K)
{
TopOpeBRepDS_Point DSP = TopOpeBRep_PointGeomTool::MakePoint(VP);
bool b = myHDS->GetGeometry(IT, DSP, G, K);
return b;
}
//=================================================================================================
int TopOpeBRep_FacesFiller::MakeGeometry(const TopOpeBRep_VPointInter& VP,
const int ShapeIndex,
TopOpeBRepDS_Kind& K)
{
int G;
bool isvertex = VP.IsVertex(ShapeIndex);
if (isvertex)
{
const TopoDS_Shape& S = VP.Vertex(ShapeIndex);
G = myDS->AddShape(S, ShapeIndex);
K = TopOpeBRepDS_VERTEX;
}
else
{
TopOpeBRepDS_Point P = TopOpeBRep_PointGeomTool::MakePoint(VP);
G = myDS->AddPoint(P);
K = TopOpeBRepDS_POINT;
}
return G;
}
//=================================================================================================
bool TopOpeBRep_FacesFiller::GetFFGeometry(const TopOpeBRepDS_Point& DSP,
TopOpeBRepDS_Kind& K,
int& G) const
{
bool found = false;
int i = myFFfirstDSP, n = myDS->NbPoints();
for (; i <= n; i++)
{
const TopOpeBRepDS_Point& OODSP = myDS->Point(i);
found = TopOpeBRep_PointGeomTool::IsEqual(DSP, OODSP);
if (found)
{
break;
}
}
if (found)
{
K = TopOpeBRepDS_POINT;
G = i;
}
return found;
}
//=================================================================================================
bool TopOpeBRep_FacesFiller::GetFFGeometry(const TopOpeBRep_VPointInter& VP,
TopOpeBRepDS_Kind& K,
int& G) const
{
TopOpeBRepDS_Point DSP = TopOpeBRep_PointGeomTool::MakePoint(VP);
bool found = GetFFGeometry(DSP, K, G);
return found;
}
f2929057eThis file is pinned to the selected release. Download the original to open it in your design tool.