mirror of
https://git.dev.opencascade.org/repos/occt.git
synced 2025-08-04 13:13:25 +03:00
0797d9d30a
Macros ending on "DEB" are replaced by OCCT_DEBUG across OCCT code; new macros described in documentation. Macros starting with DEB are changed to start with "OCCT_DEBUG_". Some code cleaned.
585 lines
21 KiB
C++
585 lines
21 KiB
C++
// Copyright (c) 1998-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.
|
|
|
|
// Robert Boehne 30 May 2000 : Dec Osf
|
|
|
|
#include <TopOpeBRepDS_FIR.ixx>
|
|
#include <TopOpeBRepDS_define.hxx>
|
|
#include <TopOpeBRepTool_EXPORT.hxx>
|
|
#include <TopOpeBRepTool_SC.hxx>
|
|
|
|
#include <TopOpeBRepDS_ProcessInterferencesTool.hxx>
|
|
#include <TopoDS.hxx>
|
|
#include <TopExp_Explorer.hxx>
|
|
#include <TopOpeBRepDS_FaceInterferenceTool.hxx>
|
|
#include <TopOpeBRepDS_CurvePointInterference.hxx>
|
|
#include <TopOpeBRepDS_ShapeShapeInterference.hxx>
|
|
#include <TopOpeBRepDS_ShapeData.hxx>
|
|
#include <TopOpeBRepDS_MapOfShapeData.hxx>
|
|
#include <BRepAdaptor_Curve.hxx>
|
|
#include <BRep_Builder.hxx>
|
|
#include <BRep_Tool.hxx>
|
|
#include <TopOpeBRepDS_ListOfShapeOn1State.hxx>
|
|
#include <TopOpeBRepDS_DataMapOfShapeListOfShapeOn1State.hxx>
|
|
|
|
#define MDSke TopOpeBRepDS_EDGE
|
|
#define MDSkf TopOpeBRepDS_FACE
|
|
|
|
#ifdef OCCT_DEBUG
|
|
void debrededg(const Standard_Integer I) {cout<<"+++ debrededg f"<<I<<endl;}
|
|
void debredfac(const Standard_Integer I) {cout<<"+++ debredfac f"<<I<<endl;}
|
|
void FUN_dumploiS(const TopoDS_Shape& SG,const TopOpeBRepDS_ListOfInterference& loi,const TopOpeBRepDS_DataStructure& BDS,TCollection_AsciiString str)
|
|
{
|
|
cout<<str<<" G : "<<BDS.Shape(SG)<<" S : ";
|
|
for(TopOpeBRepDS_ListIteratorOfListOfInterference it(loi);it.More();it.Next()) cout<<it.Value()->Support()<<" ";
|
|
cout<<endl;cout.flush();
|
|
}
|
|
void FUN_dumpmosd(TopOpeBRepDS_MapOfShapeData& mosd,const TopOpeBRepDS_DataStructure& BDS,const Standard_Integer F,TCollection_AsciiString str)
|
|
{
|
|
cout<<str<<"GmapS sur ";TopAbs::Print(BDS.Shape(F).ShapeType(),cout);
|
|
cout<<" "<<F<<" : "<<mosd.Extent()<<" (GK EDGE)(SK FACE)"<<endl;
|
|
for(Standard_Integer i=1,n=mosd.Extent();i<=n;i++) {
|
|
FUN_dumploiS(mosd.FindKey(i),mosd.FindFromIndex(i).Interferences(),BDS,str);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#ifdef OCCT_DEBUG
|
|
extern Standard_Boolean TopOpeBRepDS_GettraceSTRANGE();
|
|
extern Standard_Boolean TopOpeBRepDS_GettracePEI();
|
|
extern Standard_Boolean TopOpeBRepDS_GettracePFI();
|
|
extern Standard_Boolean TopOpeBRepDS_GettracePI();
|
|
extern Standard_Boolean TopOpeBRepDS_GettraceSPSX(const Standard_Integer);
|
|
static Standard_Boolean FTRCF(const Standard_Integer F) {
|
|
Standard_Boolean b1 = TopOpeBRepDS_GettracePFI();
|
|
Standard_Boolean b2 = TopOpeBRepDS_GettracePI();
|
|
Standard_Boolean b3 = TopOpeBRepDS_GettraceSPSX(F);
|
|
return (b1 || b2 || b3);
|
|
}
|
|
static Standard_Boolean FTRCE(const Standard_Integer E) {
|
|
Standard_Boolean b1 = TopOpeBRepDS_GettracePEI();
|
|
Standard_Boolean b2 = TopOpeBRepDS_GettracePI();
|
|
Standard_Boolean b3 = TopOpeBRepDS_GettraceSPSX(E);
|
|
return (b1 || b2 || b3);
|
|
}
|
|
#endif
|
|
|
|
Standard_EXPORT Standard_Boolean FUN_Parameters(const gp_Pnt& Pnt,const TopoDS_Shape& F,Standard_Real& u,Standard_Real& v);
|
|
Standard_EXPORT Standard_Boolean FUN_edgeofface(const TopoDS_Shape& E,const TopoDS_Shape& F);
|
|
|
|
//------------------------------------------------------
|
|
Standard_Boolean FUN_isPonF(const TopOpeBRepDS_ListOfInterference& LIF,const gp_Pnt& P,const TopOpeBRepDS_DataStructure& BDS,const TopoDS_Edge& E)
|
|
{
|
|
Standard_Boolean Pok = Standard_True;
|
|
TopOpeBRepDS_Kind GT1,ST1; Standard_Integer G1,S1;
|
|
|
|
TopOpeBRepDS_ListIteratorOfListOfInterference itF(LIF);
|
|
for (;itF.More();itF.Next()) {
|
|
Handle(TopOpeBRepDS_Interference)& IF = itF.Value(); FDS_data(IF,GT1,G1,ST1,S1);
|
|
const TopoDS_Face& F = TopoDS::Face(BDS.Shape(S1));
|
|
TopAbs_Orientation oEinF; Standard_Boolean edonfa = FUN_tool_orientEinFFORWARD(E,F,oEinF );
|
|
if ( edonfa ) Pok = Standard_True;
|
|
else {
|
|
// P est NOK pour une face de LIF : arret
|
|
Standard_Real u,v; Pok = FUN_Parameters(P,F,u,v);
|
|
if (!Pok) break;
|
|
}
|
|
}
|
|
return Pok;
|
|
}
|
|
|
|
//------------------------------------------------------
|
|
Standard_Boolean FUN_findPonF(const TopoDS_Edge& E,const TopOpeBRepDS_DataStructure& BDS, const TopOpeBRepDS_ListOfInterference& LIF,gp_Pnt& P,Standard_Real& par)
|
|
{
|
|
Standard_Boolean Pok = Standard_False;
|
|
BRepAdaptor_Curve BAC(E);
|
|
const TopOpeBRepDS_ListOfInterference& LIE = BDS.ShapeInterferences(E);
|
|
TopOpeBRepDS_ListIteratorOfListOfInterference itI; itI.Initialize(LIE);
|
|
|
|
if ( !itI.More() ) {
|
|
Pok = FUN_tool_findPinBAC(BAC,P,par);
|
|
Pok = FUN_isPonF(LIF,P,BDS,E);
|
|
return Pok;
|
|
}
|
|
|
|
TopOpeBRepDS_Kind GT1,ST1;Standard_Integer G1,S1;
|
|
for (;itI.More();itI.Next()) {
|
|
Standard_Boolean pardef = Standard_False;
|
|
|
|
Handle(TopOpeBRepDS_Interference)& I = itI.Value(); FDS_data(I,GT1,G1,ST1,S1);
|
|
const Handle(TopOpeBRepDS_CurvePointInterference)& CPI = Handle(TopOpeBRepDS_CurvePointInterference)::DownCast(I);
|
|
const Handle(TopOpeBRepDS_ShapeShapeInterference)& SSI = Handle(TopOpeBRepDS_ShapeShapeInterference)::DownCast(I);
|
|
if (!CPI.IsNull()) {
|
|
par = CPI->Parameter(); pardef = Standard_True;
|
|
}
|
|
else if (!SSI.IsNull()) {
|
|
Standard_Boolean gb = SSI->GBound();
|
|
if (gb) {
|
|
const TopoDS_Vertex& V = TopoDS::Vertex(BDS.Shape(G1));
|
|
P = BRep_Tool::Pnt(V); par = BRep_Tool::Parameter(V,E); pardef = Standard_True;
|
|
}
|
|
else {
|
|
pardef = Standard_False;
|
|
if (GT1 == TopOpeBRepDS_POINT) P = BDS.Point(G1).Point();
|
|
else if (GT1 == TopOpeBRepDS_VERTEX) P = BRep_Tool::Pnt(TopoDS::Vertex(BDS.Shape(G1)));
|
|
if (pardef) {
|
|
Standard_Real dist; pardef = FUN_tool_projPonC(P,BAC,par,dist);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
continue;
|
|
}
|
|
|
|
if (!pardef) {
|
|
continue;
|
|
}
|
|
|
|
BAC.D0(par,P);
|
|
Pok = FUN_isPonF(LIF,P,BDS,E);
|
|
// P est OK pour toutes les faces de LIF : on arrete de chercher
|
|
if (Pok) {
|
|
break;
|
|
}
|
|
}
|
|
return Pok;
|
|
}
|
|
|
|
// --------------------------------------------------------
|
|
static void FDS_DUMPTRANSITION(const Standard_Boolean
|
|
#ifdef OCCT_DEBUG
|
|
TRCF
|
|
#endif
|
|
,const TCollection_AsciiString&
|
|
#ifdef OCCT_DEBUG
|
|
str
|
|
#endif
|
|
,const Standard_Integer
|
|
#ifdef OCCT_DEBUG
|
|
iFI
|
|
#endif
|
|
,TopOpeBRepDS_FaceInterferenceTool&
|
|
#ifdef OCCT_DEBUG
|
|
FITool
|
|
#endif
|
|
)
|
|
{
|
|
#ifdef OCCT_DEBUG
|
|
if (TRCF) {
|
|
cout<<str<<iFI<<endl;
|
|
Handle(TopOpeBRepDS_Interference) IBID = new TopOpeBRepDS_Interference();
|
|
FITool.Transition(IBID);
|
|
IBID->Transition().Dump(cout);cout<<endl;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
// --------------------------------------------------------
|
|
static void FDS_ADDEDGE
|
|
(const Standard_Boolean
|
|
#ifdef OCCT_DEBUG
|
|
TRCF
|
|
#endif
|
|
,const TCollection_AsciiString&
|
|
#ifdef OCCT_DEBUG
|
|
str
|
|
#endif
|
|
,const Standard_Integer
|
|
#ifdef OCCT_DEBUG
|
|
iFI // DEB args
|
|
#endif
|
|
,TopOpeBRepDS_FaceInterferenceTool& FITool
|
|
,const TopoDS_Shape& FI
|
|
,const TopoDS_Shape& F
|
|
,const TopoDS_Shape& Ecpx
|
|
,const Standard_Boolean isEGsp
|
|
,const Handle(TopOpeBRepDS_Interference)& I
|
|
)
|
|
{
|
|
#ifdef OCCT_DEBUG
|
|
if (TRCF) {TCollection_AsciiString cr("\n"),s=str+iFI+cr;I->Dump(cout,s,cr);}
|
|
#endif
|
|
FITool.Add(FI,F,Ecpx,isEGsp,I);
|
|
#ifdef OCCT_DEBUG
|
|
FDS_DUMPTRANSITION(TRCF,"--> resultat partiel sur face ",iFI,FITool);
|
|
#endif
|
|
}
|
|
|
|
//------------------------------------------------------
|
|
// EGsp = edge splittee de iEG ( Null si iEG n'est pas splittee)
|
|
void FUN_reduceEDGEgeometry1
|
|
(TopOpeBRepDS_ListOfInterference& LI,const TopOpeBRepDS_DataStructure& BDS,const Standard_Integer iFI,const Standard_Integer iEG,const TopoDS_Shape& EGsp,
|
|
// const TopOpeBRepDS_DataMapOfShapeListOfShapeOn1State& MEsp)
|
|
const TopOpeBRepDS_DataMapOfShapeListOfShapeOn1State& )
|
|
{
|
|
Standard_Boolean TRCF = Standard_False;
|
|
#ifdef OCCT_DEBUG
|
|
Standard_Boolean TRCE = Standard_False;
|
|
TRCE = FTRCE(iEG);if (TRCE) debrededg(iEG);
|
|
TRCF = FTRCF(iFI);if (TRCF) debredfac(iFI);
|
|
#endif
|
|
|
|
TopOpeBRepDS_ListIteratorOfListOfInterference ili(LI); if (!ili.More()) return;
|
|
|
|
// choix de l'arete Ecpx, lieu de resolution de la transition complexe
|
|
const TopoDS_Face& FI = TopoDS::Face(BDS.Shape(iFI));
|
|
Standard_Boolean isEGsp = (! EGsp.IsNull());
|
|
TopoDS_Edge Ecpx;
|
|
if (isEGsp) Ecpx = TopoDS::Edge(EGsp);
|
|
else Ecpx = TopoDS::Edge(BDS.Shape(iEG));
|
|
|
|
TopOpeBRepDS_PDataStructure pbds = (TopOpeBRepDS_PDataStructure)(void*)&BDS;
|
|
TopOpeBRepDS_FaceInterferenceTool FITool(pbds);
|
|
gp_Pnt Pok; Standard_Boolean isPok = Standard_False; Standard_Real parPok;
|
|
if ( LI.Extent() >= 2) {
|
|
if ( isEGsp ) isPok = FUN_tool_findPinE(Ecpx,Pok,parPok);
|
|
else isPok = FUN_findPonF(Ecpx,BDS,LI,Pok,parPok); // NYI pas necessaire
|
|
if (!isPok) { LI.Clear(); return; }
|
|
FITool.SetEdgePntPar(Pok,parPok);
|
|
}
|
|
|
|
// xpu :090498 :
|
|
// CTS20205 : sp(e5) = sp(e4 of rank=1) and c3d(e5) c3d(e4) are diff oriented
|
|
// As transitions on face<iFI> are given relative to the geometry of e5,
|
|
// we have to complement them.
|
|
// Standard_Boolean toreverse = Standard_False;
|
|
// Standard_Boolean hsdm = !BDS.ShapeSameDomain(iEG).IsEmpty();
|
|
// if (hsdm) {
|
|
// Standard_Boolean sameoriented = Standard_False;
|
|
// Standard_Boolean ok = FUN_tool_curvesSO(TopoDS::Edge(Ecpx),parPok,TopoDS::Edge(BDS.Shape(iEG)),
|
|
// sameoriented);
|
|
// if (ok) toreverse = !sameoriented;
|
|
// }
|
|
// xpu :090498
|
|
|
|
// FI = face de reference (shape), iFI (indice)
|
|
// E = arete geometrie d'interference (shape), iEG (indice)
|
|
// LI = liste d'interf de geom iEG et dont les Support() sont a transitionner complexe
|
|
|
|
Handle(TopOpeBRepDS_Interference) I1,I2; TopOpeBRepDS_Kind GT1,ST1,GT2,ST2; Standard_Integer G1,S1,G2,S2;
|
|
TopOpeBRepDS_ListIteratorOfListOfInterference it1; it1.Initialize(LI);
|
|
while (it1.More()) {
|
|
Standard_Boolean u1 = FDS_data(it1,I1,GT1,G1,ST1,S1);if (u1) {it1.Next();continue;}
|
|
Standard_Boolean ya1 = (GT1 == MDSke); if (!ya1) {it1.Next();continue;}
|
|
|
|
Standard_Boolean isComplex = Standard_False; // True if at least two interfs on the same edge
|
|
const TopoDS_Face& F1 = TopoDS::Face(BDS.Shape(S1));
|
|
|
|
TopOpeBRepDS_ListIteratorOfListOfInterference it2(it1); it2.Next();
|
|
while (it2.More()) {
|
|
Standard_Boolean u2 = FDS_data(it2,I2,GT2,G2,ST2,S2);if (u2) {it2.Next();continue;}
|
|
Standard_Boolean ya2 = (GT2==GT1 && G2==G1 && ST2==ST1); if (!ya2) {it2.Next();continue;}
|
|
const TopoDS_Face& F2 = TopoDS::Face(BDS.Shape(S2));
|
|
if (!isComplex) {
|
|
isComplex = Standard_True;
|
|
|
|
|
|
// TopOpeBRepDS_Transition T1 = I1->Transition(); TopAbs_Orientation O1 = T1.Orientation(TopAbs_IN); // xpu :090498
|
|
// Standard_Boolean revT1 = toreverse && (M_FORWARD(O1) || M_REVERSED(O1)); // xpu :090498
|
|
#ifdef OCCT_DEBUG
|
|
// if ((TRCE || TRCF) && revT1) cout<<"-> REVERSE T"<<endl;
|
|
#endif
|
|
// if (revT1) I1->ChangeTransition() = T1.Complement(); //xpu :090498
|
|
FITool.Init(FI,Ecpx,isEGsp,I1);
|
|
FDS_ADDEDGE(TRCF,"\ninit transition complexe F",iFI,FITool,FI,F1,Ecpx,isEGsp,I1);
|
|
// if (revT1) I1->ChangeTransition() = T1.Complement(); //xpu :090498
|
|
}
|
|
|
|
// TopOpeBRepDS_Transition T2 = I2->Transition(); TopAbs_Orientation O2 = T2.Orientation(TopAbs_IN); // xpu :090498
|
|
// Standard_Boolean revT2 = toreverse && (M_FORWARD(O2) || M_REVERSED(O2)); // xpu :090498
|
|
#ifdef OCCT_DEBUG
|
|
// if ((TRCE || TRCF) && revT2) cout<<"-> REVERSE T"<<endl;
|
|
#endif
|
|
// if (revT2) I2->ChangeTransition() = T2.Complement(); //xpu :090498
|
|
FDS_ADDEDGE(TRCF,"add transition complexe F",iFI,FITool,FI,F2,Ecpx,isEGsp,I2);
|
|
// if (revT2) I2->ChangeTransition() = T2.Complement(); //xpu :090498
|
|
|
|
LI.Remove(it2);
|
|
}
|
|
if (isComplex) {
|
|
FITool.Transition(I1);
|
|
FDS_DUMPTRANSITION(TRCF,"--> result transition on face ",iFI,FITool); // DEB
|
|
}
|
|
it1.Next();
|
|
} // it1.More()
|
|
} // FUN_reduceEDGEgeometry1
|
|
|
|
//------------------------------------------------------
|
|
void FUN_GmapS(TopOpeBRepDS_ListOfInterference& LI, const TopOpeBRepDS_DataStructure& BDS, TopOpeBRepDS_MapOfShapeData& mosd)
|
|
{
|
|
mosd.Clear();
|
|
TopOpeBRepDS_Kind GT1,ST1;Standard_Integer G1,S1;
|
|
for (TopOpeBRepDS_ListIteratorOfListOfInterference it1(LI);it1.More();it1.Next()) {
|
|
Handle(TopOpeBRepDS_Interference)& I1=it1.Value(); FDS_data(I1,GT1,G1,ST1,S1);
|
|
if ( GT1 != MDSke || ST1 != MDSkf ) continue;
|
|
const TopoDS_Shape& SG1 = BDS.Shape(G1);
|
|
TopOpeBRepDS_ShapeData thedata;
|
|
if (!mosd.Contains(SG1)) mosd.Add(SG1, thedata);
|
|
mosd.ChangeFromKey(SG1).ChangeInterferences().Append(I1);
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------
|
|
TopAbs_State FUN_stateedgeface(const TopoDS_Shape& E, const TopoDS_Shape& F, gp_Pnt& P)
|
|
{
|
|
TopAbs_State state = TopAbs_UNKNOWN;
|
|
Standard_Real par; FUN_tool_findPinE(E,P,par);
|
|
Standard_Real u,v; Standard_Boolean Pok = FUN_Parameters(P,F,u,v);
|
|
if (Pok) { // classifier u,v dans F
|
|
TopOpeBRepTool_ShapeClassifier& PSC = FSC_GetPSC(F);
|
|
gp_Pnt2d Puv(u,v);
|
|
PSC.StateP2DReference(Puv);
|
|
state = PSC.State();
|
|
}
|
|
return state;
|
|
}
|
|
|
|
#define M_IN(ssstate) ((ssstate) == TopAbs_IN)
|
|
#define M_ON(ssstate) ((ssstate) == TopAbs_ON)
|
|
#define M_OUT(ssstate) ((ssstate) == TopAbs_OUT)
|
|
#define M_UNK(ssstate) ((ssstate) == TopAbs_UNK)
|
|
|
|
//------------------------------------------------------
|
|
void FUN_reduceEDGEgeometry
|
|
(TopOpeBRepDS_ListOfInterference& LI,const TopOpeBRepDS_DataStructure& BDS,const Standard_Integer iFI,
|
|
const TopOpeBRepDS_DataMapOfShapeListOfShapeOn1State& MEsp)
|
|
{
|
|
if (!LI.Extent()) return;
|
|
|
|
TopOpeBRepDS_MapOfShapeData mosd;
|
|
FUN_GmapS(LI,BDS,mosd);
|
|
|
|
#ifdef OCCT_DEBUG
|
|
Standard_Boolean TRC = FTRCF(iFI);
|
|
if (TRC) FUN_dumpmosd(mosd,BDS,iFI,"");
|
|
if (TRC) debredfac(iFI);
|
|
#endif
|
|
|
|
TopOpeBRepDS_ListOfInterference LIout;
|
|
//modified by NIZNHY-PKV Thu Mar 16 09:44:24 2000 f
|
|
Standard_Integer i, aN;
|
|
aN=mosd.Extent();
|
|
//for(Standard_Integer i=1,n=mosd.Extent(); i<=n; i++) {
|
|
//modified by NIZNHY-PKV Thu Mar 16 09:44:27 2000 t
|
|
for(i=1 ; i<=aN; i++) {
|
|
const TopoDS_Shape& EG = mosd.FindKey(i);
|
|
Standard_Integer iEG = BDS.Shape(EG);
|
|
|
|
// donnees samedomain attachees a l'arete iEG
|
|
const TopTools_ListOfShape& esdeg = BDS.ShapeSameDomain(iEG);
|
|
Standard_Boolean egissect = BDS.IsSectionEdge(TopoDS::Edge(EG));
|
|
Standard_Boolean eghasesd = (! esdeg.IsEmpty());
|
|
|
|
#ifdef OCCT_DEBUG
|
|
// Standard_Integer egiref = BDS.SameDomainRef(iEG);
|
|
// Standard_Integer egisref = (iEG == egiref);
|
|
// TopOpeBRepDS_Config egc = BDS.SameDomainOri(iEG);
|
|
#endif
|
|
|
|
TopOpeBRepDS_ListOfInterference& LIEG = mosd.ChangeFromKey(EG).ChangeInterferences();
|
|
Standard_Integer nExt = LIEG.Extent();
|
|
// LIEG = toutes les interferences dont le Support() est une
|
|
// face possedant une interference dont la Geometry() est EG.
|
|
|
|
#ifdef OCCT_DEBUG
|
|
if (TRC) FUN_dumploiS(EG,LIEG,BDS," ");
|
|
#endif
|
|
|
|
if (nExt == 0) {
|
|
continue;
|
|
}
|
|
if (nExt == 1) {
|
|
LIout.Append(LIEG);
|
|
}
|
|
|
|
else if (nExt >= 2) {
|
|
Standard_Boolean isEGsp = MEsp.IsBound(EG);
|
|
//modified by NIZNHY-PKV Thu Mar 16 11:03:44 2000 from
|
|
//Standard_Integer nEGsp = 0;
|
|
//modified by NIZNHY-PKV Thu Mar 16 11:03:49 2000 to
|
|
if (isEGsp) {
|
|
const TopOpeBRepDS_ListOfShapeOn1State& los1 = MEsp.Find(EG);
|
|
isEGsp = los1.IsSplit();
|
|
//modified by NIZNHY-PKV Thu Mar 16 11:02:40 2000 from
|
|
//if ( isEGsp ) {
|
|
// const TopTools_ListOfShape& los = los1.ListOnState();
|
|
// nEGsp = los.Extent();
|
|
//}
|
|
//modified by NIZNHY-PKV Thu Mar 16 11:02:46 2000 to
|
|
}
|
|
|
|
if ( isEGsp ) {
|
|
const TopTools_ListOfShape& los = MEsp.Find(EG).ListOnState();
|
|
TopTools_ListIteratorOfListOfShape itlos(los);
|
|
for(;itlos.More();itlos.Next()) {
|
|
// EGsp est une arete splitee de EG.
|
|
const TopoDS_Shape& EGsp = itlos.Value();
|
|
|
|
// LISFIN = liste des interferences de LI dont le Support()
|
|
// est une face contenant geometriquement l'arete EGsp
|
|
TopOpeBRepDS_ListOfInterference LISFIN;
|
|
TopOpeBRepDS_ListIteratorOfListOfInterference itLIEG(LIEG);
|
|
for(; itLIEG.More(); itLIEG.Next()) {
|
|
const Handle(TopOpeBRepDS_Interference)& ILIEG = itLIEG.Value();
|
|
Standard_Integer iS = ILIEG->Support();
|
|
TopOpeBRepDS_Kind kS = ILIEG->SupportType();
|
|
if ( kS == MDSkf ) {
|
|
const TopoDS_Shape& SFILIEG = BDS.Shape(iS);
|
|
gp_Pnt P;
|
|
TopAbs_State staef = FUN_stateedgeface(EGsp,SFILIEG,P);
|
|
|
|
Standard_Boolean Pok = M_IN(staef);
|
|
if ( eghasesd || egissect ) {
|
|
Pok = Pok || M_ON(staef);
|
|
}
|
|
|
|
if (Pok) {
|
|
LISFIN.Append(ILIEG);
|
|
}
|
|
}
|
|
} // itLIEG.More
|
|
|
|
Standard_Integer nLISFIN = LISFIN.Extent();
|
|
if (nLISFIN >= 2 ) {
|
|
Standard_Boolean gb;
|
|
gb = Handle(TopOpeBRepDS_ShapeShapeInterference)::DownCast(LISFIN.First())->GBound();
|
|
|
|
if (gb) {
|
|
//modified by NIZNHY-PKV Thu Mar 16 10:40:57 2000 f
|
|
// we have to rest at least one Interference on the face.
|
|
// To kill all of them is too bravely.
|
|
Handle(TopOpeBRepDS_Interference) anInterference = LISFIN.First();
|
|
LISFIN.Clear();
|
|
LISFIN.Append(anInterference);
|
|
//modified by NIZNHY-PKV Thu Mar 16 10:41:01 2000 t
|
|
}
|
|
else
|
|
FUN_reduceEDGEgeometry1(LISFIN,BDS,iFI,iEG,EGsp,MEsp);
|
|
}
|
|
|
|
nLISFIN = LISFIN.Extent();
|
|
if (nLISFIN)
|
|
LIout.Append(LISFIN);
|
|
}
|
|
} // isEGsp
|
|
else {
|
|
// iFI = face de reference (indice)
|
|
// E = arete geometrie d'interference (shape), iEG (indice)
|
|
// LIEG = liste d'interferences de geometrie EG
|
|
// et dont les Support() sont a transitionner complexe
|
|
TopoDS_Shape Enull;
|
|
FUN_reduceEDGEgeometry1(LIEG,BDS,iFI,iEG,Enull,MEsp);
|
|
LIout.Append(LIEG);
|
|
}
|
|
}
|
|
}
|
|
|
|
LI.Clear();
|
|
LI.Append(LIout);
|
|
} // FUN_reduceEDGEgeometry
|
|
|
|
//=======================================================================
|
|
//function : TopOpeBRepDS_FIR
|
|
//purpose :
|
|
//=======================================================================
|
|
TopOpeBRepDS_FIR::TopOpeBRepDS_FIR
|
|
(const Handle(TopOpeBRepDS_HDataStructure)& HDS) : myHDS(HDS)
|
|
{}
|
|
|
|
//=======================================================================
|
|
//function : ProcessFaceInterferences
|
|
//purpose :
|
|
//=======================================================================
|
|
void TopOpeBRepDS_FIR::ProcessFaceInterferences(const TopOpeBRepDS_DataMapOfShapeListOfShapeOn1State& M)
|
|
{
|
|
TopOpeBRepDS_DataStructure& BDS = myHDS->ChangeDS();
|
|
Standard_Integer i,nshape = BDS.NbShapes();
|
|
for (i = 1; i <= nshape; i++) {
|
|
const TopoDS_Shape& S = BDS.Shape(i);
|
|
if(S.IsNull()) continue;
|
|
if ( S.ShapeType() == TopAbs_FACE ) {
|
|
ProcessFaceInterferences(i,M);
|
|
}
|
|
}
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : ProcessFaceInterferences
|
|
//purpose :
|
|
//=======================================================================
|
|
void TopOpeBRepDS_FIR::ProcessFaceInterferences
|
|
(const Standard_Integer SIX,const TopOpeBRepDS_DataMapOfShapeListOfShapeOn1State& MEsp)
|
|
{
|
|
TopOpeBRepDS_DataStructure& BDS = myHDS->ChangeDS();
|
|
|
|
#ifdef OCCT_DEBUG
|
|
Standard_Boolean TRC = FTRCF(SIX);
|
|
if (TRC) debredfac(SIX);
|
|
#endif
|
|
// F is the Face, LI is list of interferences to compact
|
|
#ifdef OCCT_DEBUG
|
|
// const TopoDS_Shape& F = BDS.Shape(SIX);
|
|
#endif
|
|
TopOpeBRepDS_ListOfInterference& LI = BDS.ChangeShapeInterferences(SIX);
|
|
TopOpeBRepDS_ListOfInterference lw, lE, lFE, lFEF, lF; lw.Assign(LI);
|
|
|
|
#ifdef OCCT_DEBUG
|
|
Standard_Integer nF, nFE, nFEF, nE;
|
|
#endif
|
|
|
|
::FUN_selectTRASHAinterference(lw,TopAbs_FACE,lF);
|
|
::FUN_selectGKinterference(lF,MDSke,lFE);
|
|
::FUN_selectSKinterference(lFE,MDSkf,lFEF);
|
|
::FUN_selectTRASHAinterference(lw,TopAbs_EDGE,lE);
|
|
|
|
#ifdef OCCT_DEBUG
|
|
nF = lF.Extent();
|
|
nFE = lFE.Extent();
|
|
nFEF = lFEF.Extent();
|
|
nE = lE.Extent();
|
|
if(TRC){
|
|
if(nF||nFE||nFEF||nE){cout<<endl;cout<<"-----------------------"<<endl;}
|
|
if(nF) {cout<<"FACE "<<SIX<<" (FACE) : "<<nF<<endl;FDS_dumpLI(lF," ");}
|
|
if(nFE){cout<<"FACE "<<SIX<<" (FACE)(GK EDGE) : "<<nFE<<endl;FDS_dumpLI(lFE," ");}
|
|
if(nFEF){cout<<"FACE "<<SIX<<" (FACE)(GK EDGE)(SK FACE) : "<<nFEF<<endl;FDS_dumpLI(lFEF," ");}
|
|
if(nE) {cout<<"FACE "<<SIX<<" (EDGE) : "<<nE<<endl;FDS_dumpLI(lE," ");}
|
|
}
|
|
#endif
|
|
|
|
FUN_reduceEDGEgeometry(lFEF,BDS,SIX,MEsp);
|
|
|
|
#ifdef OCCT_DEBUG
|
|
nF = lF.Extent();
|
|
nFE = lFE.Extent();
|
|
nFEF = lFEF.Extent();
|
|
nE = lE.Extent();
|
|
if(TRC){
|
|
if(nF||nFE||nFEF||nE)cout<<endl;
|
|
if(nF) {cout<<"FACE "<<SIX<<" (FACE) : "<<nF<<endl;FDS_dumpLI(lF," ");}
|
|
if(nFE){cout<<"FACE "<<SIX<<" (FACE)(GK EDGE) : "<<nFE<<endl;FDS_dumpLI(lFE," ");}
|
|
if(nFEF){cout<<"FACE "<<SIX<<" (FACE)(GK EDGE)(SK FACE) : "<<nFEF<<endl;FDS_dumpLI(lFEF," ");}
|
|
if(nE) {cout<<"FACE "<<SIX<<" (EDGE) : "<<nE<<endl;FDS_dumpLI(lE," ");}
|
|
cout<<"-----------------------"<<endl;
|
|
}
|
|
#endif
|
|
|
|
LI.Clear();
|
|
LI.Append(lF);
|
|
LI.Append(lFE);
|
|
LI.Append(lFEF);
|
|
LI.Append(lE);
|
|
// MSV: filter duplicates
|
|
::FUN_reducedoublons(LI,BDS,SIX);
|
|
}
|