mirror of
https://git.dev.opencascade.org/repos/occt.git
synced 2025-04-08 18:40:55 +03:00
1103eb60af
NCollection containers update:
- NCollection_Array1 - updated functionality
- NCollection_Array2 - NCollection_Array1 as a wrapper for 2array
- NCollection_Vector -> NCollection_DynamicArray was renamed and reworked.
TCollection:
- Use static empty string to avoid allocations on empty string
NCollection allocators update:
- NCollection_Allocator - allocator that used Standard::Allocate
- NCollection_OccAllocator - allocator-wrapper that used OCC BaseAllocator objects
- NCollection_IncAllocator - rework to increase performance
Standard:
- Rework functionality to use different allocation libs
- Implement basic of new way to wrap allocations tools
- Define 4 ways to allocation (defines in configure stage)
Additional changes:
- Hash function uses std::hash functionality
- size_t as a hash value
- New HashUtils with Murmur and FVN hash algo for x32 and x64
- Deprecated _0.cxx and .gxx DE classes reorganized
- Create own utility for std memory
- Update Standard_Transient to be more platform-independent
Math TK changes:
- math_Vector -> match_BaseVector<>
- Buffer decreased to cash 32 elements instead of 512
1183 lines
41 KiB
C++
1183 lines
41 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 <gp_Pnt.hxx>
|
|
#include <TopExp.hxx>
|
|
#include <TopoDS.hxx>
|
|
#include <TopoDS_Shape.hxx>
|
|
#include <TopOpeBRepBuild_define.hxx>
|
|
#include <TopOpeBRepBuild_FaceBuilder.hxx>
|
|
#include <TopOpeBRepBuild_GTopo.hxx>
|
|
#include <TopOpeBRepBuild_PaveSet.hxx>
|
|
#include <TopOpeBRepBuild_ShapeSet.hxx>
|
|
#include <TopOpeBRepBuild_WireEdgeSet.hxx>
|
|
#include <TopOpeBRepDS.hxx>
|
|
#include <TopOpeBRepDS_CurveIterator.hxx>
|
|
#include <TopOpeBRepDS_HDataStructure.hxx>
|
|
#include <TopOpeBRepDS_InterferenceTool.hxx>
|
|
#include <TopOpeBRepDS_ProcessInterferencesTool.hxx>
|
|
#include <TopOpeBRepTool_2d.hxx>
|
|
#include <TopOpeBRepTool_EXPORT.hxx>
|
|
#include <TopOpeBRepTool_ShapeExplorer.hxx>
|
|
#include <TopOpeBRepTool_ShapeTool.hxx>
|
|
#include <TopOpeBRepTool_TOOL.hxx>
|
|
|
|
#ifdef DRAW
|
|
Standard_IMPORT void FUN_draw(const TopoDS_Shape& s);
|
|
Standard_IMPORT void FUN_draw2de (const TopoDS_Shape& ed,const TopoDS_Shape& fa);
|
|
#endif
|
|
|
|
#ifdef OCCT_DEBUG
|
|
extern void* GFABUMAKEFACEPWES_DEB;
|
|
#define DEBSHASET(sarg,meth,shaset,str) TCollection_AsciiString sarg((meth));(sarg)=(sarg)+(shaset).DEBNumber()+(str);
|
|
Standard_Integer GLOBAL_iexE = 0;
|
|
Standard_EXPORT void debfillw(const Standard_Integer /*i*/) {}
|
|
Standard_EXPORT void debfille(const Standard_Integer /*i*/) {}
|
|
Standard_EXPORT void debffwesON(const Standard_Integer i) {std::cout<<"++ debffwesON "<<i<<std::endl;}
|
|
Standard_EXPORT void debffwesmf(const Standard_Integer i) {std::cout<<"++ debffwesmf "<<i<<std::endl;}
|
|
Standard_EXPORT void debfillf(const Standard_Integer i) {std::cout<<"++ debfillf "<<i<<std::endl;}
|
|
Standard_EXPORT void debsplite(const Standard_Integer i) {std::cout<<"++ debsplite "<<i<<std::endl;}
|
|
Standard_EXPORT void debmergef(const Standard_Integer i) {std::cout<<"++ debmergef "<<i<<std::endl;}
|
|
Standard_IMPORT void debfctwesmess(const Standard_Integer i,
|
|
const TCollection_AsciiString& s = "");
|
|
extern void debaddpwes(const Standard_Integer iFOR, const TopAbs_State TB1, const Standard_Integer iEG,
|
|
const TopAbs_Orientation neworiE, const TopOpeBRepBuild_PBuilder& PB,
|
|
const TopOpeBRepBuild_PWireEdgeSet& PWES, const TCollection_AsciiString& str1,
|
|
const TCollection_AsciiString& str2);
|
|
#endif
|
|
|
|
Standard_Boolean GLOBAL_faces2d = Standard_False;
|
|
Standard_EXPORT Standard_Boolean GLOBAL_classifysplitedge = Standard_False;
|
|
|
|
#define M_IN(st ) (st == TopAbs_IN)
|
|
#define M_OUT(st) (st == TopAbs_OUT)
|
|
#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)
|
|
|
|
Standard_IMPORT Standard_Boolean FUN_HDS_FACESINTERFER(const TopoDS_Shape& F1,
|
|
const TopoDS_Shape& F2,
|
|
const Handle(TopOpeBRepDS_HDataStructure)& HDS);
|
|
|
|
static
|
|
TopAbs_State ClassifyEdgeToSolidByOnePoint(const TopoDS_Edge& E,
|
|
const TopoDS_Shape& Ref);
|
|
static
|
|
Standard_Boolean FUN_computeLIFfaces2d(const TopOpeBRepBuild_Builder& BU,
|
|
const TopoDS_Face& F,
|
|
const TopoDS_Edge& E,
|
|
TopOpeBRepDS_PDataStructure& pDS2d);
|
|
static
|
|
Standard_Boolean FUN_computeLIFfaces2d(const TopOpeBRepBuild_Builder& BU,
|
|
const TopoDS_Face& F,
|
|
TopOpeBRepDS_PDataStructure& pDS2d);
|
|
|
|
//-------------------------------------------------------------
|
|
// Unused :
|
|
/*#ifdef OCCT_DEBUG
|
|
//=======================================================================
|
|
//function :FUN_BUI_FACESINTERFER
|
|
//purpose :
|
|
//=======================================================================
|
|
static Standard_Boolean FUN_BUI_FACESINTERFER(const TopoDS_Shape& F1,
|
|
const TopoDS_Shape& F2,
|
|
const TopOpeBRepBuild_Builder& B)
|
|
{
|
|
Standard_Boolean yainterf = Standard_False;
|
|
Handle(TopOpeBRepDS_HDataStructure) HDS = B.DataStructure();
|
|
|
|
|
|
|
|
Standard_Boolean ya1 = FUN_HDS_FACESINTERFER(F1,F2,HDS);
|
|
Standard_Boolean ya2 = FUN_HDS_FACESINTERFER(F2,F1,HDS);
|
|
yainterf = (ya1 && ya2);
|
|
return yainterf;
|
|
}
|
|
#endif*/
|
|
|
|
//=======================================================================
|
|
//function :TopOpeBRepBuild_FUN_aresamegeom
|
|
//purpose :
|
|
//=======================================================================
|
|
Standard_Boolean TopOpeBRepBuild_FUN_aresamegeom (const TopoDS_Shape& S1,
|
|
const TopoDS_Shape& S2)
|
|
{
|
|
TopoDS_Shape SF1 = S1;
|
|
SF1.Orientation(TopAbs_FORWARD);
|
|
TopoDS_Shape SF2 = S2;
|
|
SF2.Orientation(TopAbs_FORWARD);
|
|
Standard_Boolean same = TopOpeBRepTool_ShapeTool::ShapesSameOriented(SF1,SF2);
|
|
return same;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function :FUN_computeLIFfaces2d
|
|
//purpose :
|
|
//=======================================================================
|
|
Standard_Boolean FUN_computeLIFfaces2d(const TopOpeBRepBuild_Builder& BU,
|
|
const TopoDS_Face& F,
|
|
const TopoDS_Edge& E,
|
|
TopOpeBRepDS_PDataStructure& pDS2d)
|
|
// purpose : compute new face/face interferences F FTRA,
|
|
// {I = (T(F),ES,FTRA)} / Fsdm F and ES interfers with E which has splits ON
|
|
// E is edge of F
|
|
{
|
|
const TopOpeBRepDS_DataStructure& BDS = BU.DataStructure()->DS();
|
|
const TopOpeBRepDS_ListOfInterference& LI = BDS.ShapeInterferences(E);
|
|
Standard_Integer IE = BDS.Shape(E);
|
|
Standard_Integer IF = BDS.Shape(F);
|
|
Standard_Integer rkF = BDS.AncestorRank(F);
|
|
Standard_Boolean hasspE = BU.IsSplit(E,TopAbs_ON);
|
|
if (hasspE) hasspE = (BU.Splits(E,TopAbs_ON).Extent() > 0);
|
|
TopTools_MapOfShape Ffound;
|
|
|
|
TopTools_ListOfShape Fsdm; TopTools_ListIteratorOfListOfShape itf(BDS.ShapeSameDomain(F));
|
|
for (; itf.More(); itf.Next()){
|
|
const TopoDS_Shape& f = itf.Value();
|
|
Standard_Integer rkf = BDS.AncestorRank(f);
|
|
if (rkf == rkF) continue;
|
|
Fsdm.Append(f);
|
|
}
|
|
|
|
for (TopOpeBRepDS_ListIteratorOfListOfInterference itI(LI); itI.More(); itI.Next()){
|
|
const Handle(TopOpeBRepDS_Interference)& I = itI.Value();
|
|
// const TopOpeBRepDS_Transition& T = I->Transition();
|
|
TopAbs_ShapeEnum SB,SA;Standard_Integer IB,IA;TopOpeBRepDS_Kind GT,ST;Standard_Integer G,S;
|
|
FDS_Idata(I,SB,IB,SA,IA,GT,G,ST,S);
|
|
if (ST != TopOpeBRepDS_EDGE) return Standard_False;
|
|
|
|
TopoDS_Face FTRA; Standard_Integer ITRA = IB;
|
|
if (SB == TopAbs_FACE) FTRA = TopoDS::Face(BDS.Shape(IB));
|
|
else if (SB == TopAbs_EDGE) {
|
|
Standard_Boolean ok = FUN_tool_findAncestor(Fsdm,TopoDS::Edge(BDS.Shape(S)),FTRA);
|
|
ITRA = BDS.Shape(FTRA);
|
|
if (!ok) return Standard_False;
|
|
}
|
|
Standard_Boolean found = Ffound.Contains(FTRA);
|
|
|
|
// prequesitory : F and FTRA are SDSO
|
|
// -------------
|
|
|
|
// attached to E : I = (T(FTRA),G,ES),
|
|
// ES : support edge
|
|
// GP : geometric point
|
|
// recall : rankE = rankF
|
|
// rankTRA = rankS != rankE
|
|
Standard_Real parE = FDS_Parameter(I);
|
|
const TopoDS_Edge& ES = TopoDS::Edge(BDS.Shape(S));
|
|
Standard_Boolean hasspES = BU.IsSplit(ES,TopAbs_ON);
|
|
if (hasspES) hasspE = (BU.Splits(ES,TopAbs_ON).Extent() > 0);
|
|
|
|
Standard_Boolean sdm = FUN_ds_sdm(BDS,E,ES);
|
|
Standard_Boolean mkTonEsdm = sdm && hasspE && !found;
|
|
Standard_Boolean hasfeiF_E_FTRA = FUN_ds_hasFEI(pDS2d,F,IE,ITRA); //xpu120698
|
|
mkTonEsdm = mkTonEsdm && !hasfeiF_E_FTRA; //xpu120698
|
|
if (mkTonEsdm) {
|
|
Ffound.Add(FTRA);
|
|
TopoDS_Edge dummy; TopOpeBRepDS_Transition newT;
|
|
Standard_Boolean ok = FUN_ds_mkTonFsdm(BU.DataStructure(),IF,ITRA,S,IE,parE,dummy,Standard_True,newT);
|
|
|
|
if (ok) {
|
|
newT.Index(ITRA); TopOpeBRepDS_Config C = TopOpeBRepDS_SAMEORIENTED;
|
|
Handle(TopOpeBRepDS_Interference) newI = TopOpeBRepDS_InterferenceTool::MakeFaceEdgeInterference(newT,ITRA,IE,Standard_True,C);
|
|
pDS2d->AddShapeInterference(F,newI);
|
|
}
|
|
}
|
|
Standard_Boolean mkTonESsdm = sdm && hasspES;
|
|
Standard_Boolean hasfeiFRA_E_F = FUN_ds_hasFEI(pDS2d,FTRA,IE,IF); //xpu120698
|
|
mkTonESsdm = mkTonESsdm && !hasfeiFRA_E_F; //xpu120698
|
|
if (mkTonESsdm) { // ff1, IE=3 has interferences, S=8 has none
|
|
TopoDS_Edge dummy; TopOpeBRepDS_Transition newT;
|
|
|
|
Standard_Real parES; Standard_Boolean ok = FUN_tool_parE(E,parE,ES,parES);
|
|
if (!ok) continue;
|
|
ok = FUN_ds_mkTonFsdm(BU.DataStructure(),ITRA,IF,IE,S,parES,dummy,Standard_True,newT);
|
|
if (ok) {
|
|
newT.Index(IF); TopOpeBRepDS_Config C = TopOpeBRepDS_SAMEORIENTED;
|
|
Handle(TopOpeBRepDS_Interference) newI = TopOpeBRepDS_InterferenceTool::MakeFaceEdgeInterference(newT,IF,IE,Standard_False,C);
|
|
pDS2d->AddShapeInterference(FTRA,newI);
|
|
}
|
|
|
|
ok = FUN_ds_mkTonFsdm(BU.DataStructure(),ITRA,IF,IE,IE,parE,dummy,Standard_True,newT);
|
|
if (ok) {
|
|
newT.Index(IF); TopOpeBRepDS_Config C = TopOpeBRepDS_SAMEORIENTED;
|
|
Handle(TopOpeBRepDS_Interference) newI = TopOpeBRepDS_InterferenceTool::MakeFaceEdgeInterference(newT,IF,S,Standard_True,C);
|
|
pDS2d->AddShapeInterference(FTRA,newI);
|
|
}
|
|
|
|
}
|
|
|
|
Standard_Boolean mkTonES = hasspES;
|
|
Standard_Boolean hasfeiF_S_FTRA = FUN_ds_hasFEI(pDS2d,F,S,ITRA); //xpu120698
|
|
mkTonES = mkTonES && !hasfeiF_S_FTRA;
|
|
if (mkTonES) {
|
|
Standard_Real parES; Standard_Boolean ok = FUN_tool_parE(E,parE,ES,parES);
|
|
if (!ok) continue;
|
|
|
|
TopoDS_Edge dummy; TopOpeBRepDS_Transition newT;
|
|
ok = FUN_ds_mkTonFsdm(BU.DataStructure(),IF,ITRA,S,S,parES,dummy,Standard_True,newT);
|
|
|
|
if (ok) {
|
|
newT.Index(ITRA); TopOpeBRepDS_Config C = TopOpeBRepDS_SAMEORIENTED;
|
|
Handle(TopOpeBRepDS_Interference) newI = TopOpeBRepDS_InterferenceTool::MakeFaceEdgeInterference(newT,ITRA,S,Standard_False,C);
|
|
pDS2d->AddShapeInterference(F,newI);
|
|
}
|
|
}
|
|
} // itI(LI)
|
|
|
|
return Standard_True;
|
|
}
|
|
//=======================================================================
|
|
//function :FUN_computeLIFfaces2d
|
|
//purpose :
|
|
//=======================================================================
|
|
Standard_Boolean FUN_computeLIFfaces2d(const TopOpeBRepBuild_Builder& BU,
|
|
const TopoDS_Face& F,
|
|
TopOpeBRepDS_PDataStructure& pDS2d)
|
|
{
|
|
TopExp_Explorer ex(F, TopAbs_EDGE);
|
|
for (; ex.More(); ex.Next()){
|
|
const TopoDS_Edge& E = TopoDS::Edge(ex.Current());
|
|
Standard_Boolean ok = FUN_computeLIFfaces2d(BU,F,E,pDS2d);
|
|
if (!ok) return Standard_False;
|
|
}
|
|
return Standard_True;
|
|
}
|
|
//=======================================================================
|
|
//variable : Standard_EXPORT TopOpeBRepDS_PDataStructure GLOBAL_DS2d
|
|
//purpose :
|
|
//=======================================================================
|
|
Standard_EXPORT TopOpeBRepDS_PDataStructure GLOBAL_DS2d = NULL;
|
|
|
|
//=======================================================================
|
|
//function : GMergeFaces
|
|
//purpose :
|
|
//=======================================================================
|
|
void TopOpeBRepBuild_Builder::GMergeFaces(const TopTools_ListOfShape& LF1,
|
|
const TopTools_ListOfShape& LF2,
|
|
const TopOpeBRepBuild_GTopo& G1)
|
|
{
|
|
if ( LF1.IsEmpty() ) return;
|
|
if (GLOBAL_DS2d == NULL) GLOBAL_DS2d = (TopOpeBRepDS_PDataStructure)new TopOpeBRepDS_DataStructure();
|
|
GLOBAL_DS2d->Init();
|
|
|
|
TopAbs_State TB1,TB2; G1.StatesON(TB1,TB2);
|
|
|
|
const TopoDS_Shape& F1 = LF1.First();
|
|
#ifdef OCCT_DEBUG
|
|
Standard_Integer iF; Standard_Boolean tSPS = GtraceSPS(F1,iF);
|
|
if(tSPS){
|
|
std::cout<<std::endl<<"--- GMergeFaces "<<std::endl;
|
|
GdumpSAMDOM(LF1, (char *) "1 : ");
|
|
GdumpSAMDOM(LF2, (char *) "2 : ");
|
|
debmergef(iF);
|
|
}
|
|
#endif
|
|
|
|
// xpu070598 : filling up DS2
|
|
// for (TopTools_ListIteratorOfListOfShape itF1(LF1); itF1.More(); itF1.Next()) GLOBAL_DS2d->AddShape(itF1.Value(),1);
|
|
TopTools_ListIteratorOfListOfShape itF1(LF1) ;
|
|
for ( ; itF1.More(); itF1.Next()) GLOBAL_DS2d->AddShape(itF1.Value(),1);
|
|
// for (TopTools_ListIteratorOfListOfShape itF2(LF2); itF2.More(); itF2.Next()) GLOBAL_DS2d->AddShape(itF2.Value(),2);
|
|
TopTools_ListIteratorOfListOfShape itF2(LF2) ;
|
|
for ( ; itF2.More(); itF2.Next()) GLOBAL_DS2d->AddShape(itF2.Value(),2);
|
|
|
|
// for (itF1.Initialize(LF1); itF1.More(); itF1.Next()){
|
|
itF1.Initialize(LF1) ;
|
|
for ( ; itF1.More(); itF1.Next()){
|
|
const TopoDS_Face& FF1 = TopoDS::Face(itF1.Value());
|
|
FUN_computeLIFfaces2d((*this),TopoDS::Face(FF1),GLOBAL_DS2d);
|
|
}
|
|
// for (itF2.Initialize(LF2); itF2.More(); itF2.Next()){
|
|
itF2.Initialize(LF2) ;
|
|
for ( ; itF2.More(); itF2.Next()){
|
|
const TopoDS_Face& FF2 = TopoDS::Face(itF2.Value());
|
|
FUN_computeLIFfaces2d((*this),TopoDS::Face(FF2),GLOBAL_DS2d);
|
|
}
|
|
// xpu070598
|
|
|
|
{
|
|
for (Standard_Integer ii=1; ii<=GLOBAL_DS2d->NbShapes(); ii++) {
|
|
TopOpeBRepDS_ListOfInterference& LI = GLOBAL_DS2d->ChangeShapeInterferences(ii);
|
|
FUN_reducedoublons(LI,(*GLOBAL_DS2d),ii);
|
|
}
|
|
}
|
|
|
|
myFaceReference = TopoDS::Face(F1);
|
|
TopOpeBRepBuild_WireEdgeSet WES(F1,this);
|
|
|
|
GLOBAL_faces2d = Standard_True;
|
|
Standard_Integer K1=1; GFillFacesWESK(LF1,LF2,G1,WES,K1);
|
|
Standard_Integer K3=3; GFillFacesWESK(LF1,LF2,G1,WES,K3); // xpu060598
|
|
GLOBAL_faces2d = Standard_False;
|
|
|
|
// Create a face builder FABU
|
|
TopoDS_Shape F1F = LF1.First(); F1F.Orientation(TopAbs_FORWARD);
|
|
Standard_Boolean ForceClass = Standard_True;
|
|
TopOpeBRepBuild_FaceBuilder FABU;
|
|
FABU.InitFaceBuilder(WES,F1F,ForceClass);
|
|
|
|
// Build new faces LFM
|
|
TopTools_ListOfShape LFM;
|
|
|
|
#ifdef OCCT_DEBUG
|
|
GFABUMAKEFACEPWES_DEB = (void*)&WES;
|
|
#endif
|
|
|
|
TopTools_DataMapOfShapeInteger MWisOld;
|
|
GFABUMakeFaces(F1F,FABU,LFM,MWisOld);
|
|
|
|
// xpu281098 : regularisation after GFABUMakeFaces
|
|
TopTools_ListOfShape newLFM; RegularizeFaces(F1F,LFM,newLFM);
|
|
LFM.Clear(); LFM.Assign(newLFM);
|
|
|
|
// connect new faces as faces built TB1 on LF1 faces
|
|
TopTools_ListIteratorOfListOfShape it1;
|
|
for (it1.Initialize(LF1); it1.More(); it1.Next()) {
|
|
const TopoDS_Shape& F1x = it1.Value();
|
|
Standard_Boolean tomerge = !IsMerged(F1x,TB1);
|
|
if (tomerge) {
|
|
ChangeMerged(F1x, TB1) = LFM;
|
|
}
|
|
}
|
|
|
|
// connect new faces as faces built TB2 on LF2 faces
|
|
TopTools_ListIteratorOfListOfShape it2;
|
|
for (it2.Initialize(LF2); it2.More(); it2.Next()) {
|
|
const TopoDS_Shape& F2 = it2.Value();
|
|
Standard_Boolean tomerge = !IsMerged(F2,TB2);
|
|
if (tomerge) ChangeMerged(F2,TB2) = LFM;
|
|
}
|
|
|
|
} // GMergeFaces
|
|
|
|
//=======================================================================
|
|
//function : GFillFacesWES
|
|
//purpose :
|
|
//=======================================================================
|
|
void TopOpeBRepBuild_Builder::GFillFacesWES(const TopTools_ListOfShape& ,
|
|
const TopTools_ListOfShape& ,
|
|
const TopOpeBRepBuild_GTopo& ,
|
|
TopOpeBRepBuild_WireEdgeSet& )
|
|
{
|
|
} // GFillFacesWES
|
|
|
|
static Standard_Boolean FUN_validF1edge(const TopoDS_Shape& F)
|
|
{
|
|
Standard_Integer nE = 0;
|
|
TopTools_IndexedMapOfShape mEt;
|
|
TopExp_Explorer exE(F, TopAbs_EDGE);
|
|
// for ( exE ; exE.More(); exE.Next()) {
|
|
for ( ; exE.More(); exE.Next()) {
|
|
const TopoDS_Shape& e = exE.Current();
|
|
if (mEt.Contains(e)) continue;
|
|
mEt.Add(e);
|
|
nE++;
|
|
if (nE > 2) break;
|
|
}
|
|
if (nE > 1) return Standard_True;
|
|
if (nE == 1) {
|
|
exE.Init(F, TopAbs_EDGE);
|
|
const TopoDS_Edge& e = TopoDS::Edge(exE.Current());
|
|
TopoDS_Vertex dummy; Standard_Boolean closed = TopOpeBRepTool_TOOL::ClosedE(e,dummy);
|
|
return closed;
|
|
}
|
|
return Standard_False;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : GFillFacesWESMakeFaces
|
|
//purpose :
|
|
//=======================================================================
|
|
void TopOpeBRepBuild_Builder::GFillFacesWESMakeFaces(const TopTools_ListOfShape& LLF1,
|
|
const TopTools_ListOfShape& LF2,
|
|
const TopTools_ListOfShape& ,//LSO,
|
|
const TopOpeBRepBuild_GTopo& GM)
|
|
{
|
|
TopAbs_State TB1,TB2; GM.StatesON(TB1,TB2);
|
|
if (LLF1.IsEmpty()) return;
|
|
|
|
// xpu270898 : cto905E2 split(fref6,f33,f16) must be built on fref6
|
|
TopTools_ListOfShape LF1;
|
|
TopTools_ListIteratorOfListOfShape itf(LLF1);
|
|
const TopOpeBRepDS_DataStructure& BDS = myDataStructure->DS();
|
|
Standard_Integer iref = 0;
|
|
for (; itf.More(); itf.Next()){
|
|
const TopoDS_Shape& fcur = itf.Value();
|
|
Standard_Integer icur = BDS.Shape(fcur);
|
|
iref = BDS.SameDomainRef(fcur);
|
|
if (icur == iref) LF1.Prepend(fcur);
|
|
else LF1.Append(fcur);
|
|
}
|
|
// xpu270898 : cto905I1 split(f6,f30,fref14) must be built on fref6, f6 is in LFDO1
|
|
// Standard_Boolean FFinDO1 = (iFF == iref);
|
|
// const TopoDS_Shape& FF = BDS.Shape(iref);
|
|
const TopoDS_Shape& FF = LF1.First().Oriented(TopAbs_FORWARD);
|
|
Standard_Integer iFF = BDS.Shape(FF);
|
|
|
|
TopOpeBRepBuild_WireEdgeSet WES(FF,this);
|
|
|
|
#ifdef OCCT_DEBUG
|
|
Standard_Integer iF; Standard_Boolean tSPS = GtraceSPS(FF,iF);
|
|
if(tSPS) GdumpSHASTA(iF,TB1,WES,"\n--- GFillFacesWESMakeFaces");
|
|
if(tSPS) debfillf(iF);
|
|
if(tSPS) debffwesmf(iF);
|
|
#endif
|
|
|
|
Standard_Integer n1 = 0;
|
|
GLOBAL_faces2d = Standard_True;
|
|
Standard_Integer K1=1; GFillFacesWESK(LF1,LF2,GM,WES,K1);
|
|
GLOBAL_faces2d = Standard_False;
|
|
n1 = WES.StartElements().Extent();
|
|
|
|
Standard_Integer K2=2; GFillFacesWESK(LF1,LF2,GM,WES,K2);
|
|
n1 = WES.StartElements().Extent();
|
|
|
|
Standard_Integer K3=3; GFillFacesWESK(LF1,LF2,GM,WES,K3);
|
|
n1 = WES.StartElements().Extent();
|
|
|
|
Standard_Integer n2 = WES.StartElements().Extent();
|
|
myEdgeAvoid.Clear(); // Start edges dues a GFillCurveTopologyWES
|
|
GCopyList(WES.StartElements(),(n1+1),n2,myEdgeAvoid);
|
|
TopTools_ListOfShape LOF; // LOF : toutes les faces construites sur WES
|
|
GWESMakeFaces(FF,WES,LOF);
|
|
|
|
// xpu290498
|
|
//cto 001 F2 : spIN(f18)
|
|
TopTools_ListIteratorOfListOfShape itF(LOF);
|
|
while (itF.More()){
|
|
const TopoDS_Shape& F = itF.Value();
|
|
Standard_Boolean valid = ::FUN_validF1edge(F);
|
|
if (!valid) LOF.Remove(itF);
|
|
else itF.Next();
|
|
}
|
|
// xpu290498
|
|
|
|
TopTools_ListOfShape LOFS; // LOFS : LOF faces situees TB1/LSO2
|
|
GKeepShapes(FF,myEmptyShapeList,TB1,LOF,LOFS);
|
|
|
|
// les faces construites (LOFS) prennent l'orientation originale de FF
|
|
TopAbs_Orientation odsFF = myDataStructure->Shape(iFF).Orientation();
|
|
for(TopTools_ListIteratorOfListOfShape itt(LOFS);itt.More();itt.Next()) itt.ChangeValue().Orientation(odsFF);
|
|
|
|
TopTools_ListIteratorOfListOfShape it1;
|
|
for (it1.Initialize(LF1); it1.More(); it1.Next()) {
|
|
const TopoDS_Shape& S = it1.Value();
|
|
#ifdef OCCT_DEBUG
|
|
Standard_Integer iS; GtraceSPS(S,iS);
|
|
#endif
|
|
MarkSplit(S,TB1);
|
|
TopTools_ListOfShape& LS1 = ChangeSplit(S,TB1);
|
|
GCopyList(LOFS,LS1);
|
|
}
|
|
|
|
TopTools_ListIteratorOfListOfShape it2;
|
|
for (it2.Initialize(LF2); it2.More(); it2.Next()) {
|
|
const TopoDS_Shape& S = it2.Value();
|
|
#ifdef OCCT_DEBUG
|
|
Standard_Integer iS; GtraceSPS(S,iS);
|
|
#endif
|
|
MarkSplit(S,TB2);
|
|
TopTools_ListOfShape& LS2 = ChangeSplit(S,TB2);
|
|
GCopyList(LOFS,LS2);
|
|
}
|
|
} // GFillFacesWESMakeFaces
|
|
|
|
//=======================================================================
|
|
//function : GFillFaceWES
|
|
//purpose :
|
|
//=======================================================================
|
|
void TopOpeBRepBuild_Builder::GFillFaceWES(const TopoDS_Shape& FOR1,
|
|
const TopTools_ListOfShape& LFclass,
|
|
const TopOpeBRepBuild_GTopo& G1,
|
|
TopOpeBRepBuild_WireEdgeSet& WES)
|
|
{
|
|
TopAbs_State TB1,TB2; G1.StatesON(TB1,TB2);
|
|
Standard_Boolean RevOri1 = G1.IsToReverse1();
|
|
|
|
#ifdef OCCT_DEBUG
|
|
Standard_Integer iF; Standard_Boolean tSPS = GtraceSPS(FOR1,iF);
|
|
if(tSPS) GdumpSHASTA(iF,TB1,WES,"--- GFillFaceWES","START");
|
|
if(tSPS) debfillf(iF);
|
|
#endif
|
|
|
|
// xpu200598 bcl1;bcl2; tsp(f9)
|
|
Standard_Boolean opeCut = Opec12() || Opec21(); //xpu200598
|
|
Standard_Boolean ComOfCut = opeCut && (TB1 == TB2) && (TB1 == TopAbs_IN); //xpu200598
|
|
Standard_Boolean hsdm = myDataStructure->HasSameDomain(FOR1);//xpu200598
|
|
if (hsdm && ComOfCut) return; //xpu200598
|
|
|
|
// work on a FORWARD face FF
|
|
TopoDS_Shape FF = FOR1; FF.Orientation(TopAbs_FORWARD);
|
|
myFaceToFill = TopoDS::Face(FF);
|
|
|
|
TopOpeBRepTool_ShapeExplorer exWire(FF,TopAbs_WIRE);
|
|
for (; exWire.More(); exWire.Next()) {
|
|
TopoDS_Shape W = exWire.Current();
|
|
Standard_Boolean hasshape = myDataStructure->HasShape(W);
|
|
|
|
if ( ! hasshape ) {
|
|
// wire W is not in DS : classify it with LFclass faces
|
|
TopAbs_State pos;
|
|
Standard_Boolean keep = GKeepShape1(W,LFclass,TB1,pos);
|
|
if (keep) {
|
|
TopAbs_Orientation oriW = W.Orientation();
|
|
TopAbs_Orientation neworiW = Orient(oriW,RevOri1);
|
|
W.Orientation(neworiW);
|
|
WES.AddShape(W);
|
|
}
|
|
else if (myProcessON && pos == TopAbs_ON)
|
|
myONElemMap.Add(W);
|
|
}
|
|
else { // wire W has edges(s) with geometry : split W edges
|
|
GFillWireWES(W,LFclass,G1,WES);
|
|
}
|
|
}
|
|
|
|
#ifdef OCCT_DEBUG
|
|
if(tSPS) GdumpSHASTA(iF,TB1,WES,"--- GFillFaceWES","END");
|
|
#endif
|
|
|
|
return;
|
|
} // GFillFaceWES
|
|
|
|
//=======================================================================
|
|
//function : GFillWireWES
|
|
//purpose :
|
|
//=======================================================================
|
|
void TopOpeBRepBuild_Builder::GFillWireWES(const TopoDS_Shape& W,
|
|
const TopTools_ListOfShape& LSclass,
|
|
const TopOpeBRepBuild_GTopo& G1,
|
|
TopOpeBRepBuild_WireEdgeSet& WES)
|
|
{
|
|
TopAbs_State TB1,TB2; G1.StatesON(TB1,TB2);
|
|
|
|
#ifdef OCCT_DEBUG
|
|
Standard_Integer iW; Standard_Boolean tSPS = GtraceSPS(W,iW);
|
|
if(tSPS){
|
|
std::cout<<std::endl;DEBSHASET(s,"--- GFillWireWES ",WES," ");
|
|
GdumpSHA(W,(Standard_Address)s.ToCString()); std::cout<<std::endl;
|
|
Standard_Integer nbe = 0;
|
|
TopOpeBRepTool_ShapeExplorer exE(W,TopAbs_EDGE);for (;exE.More(); exE.Next()) nbe++;
|
|
std::cout<<"--- GFillWireWES on W "<<iW<<" with "<<nbe<<" edges "<<std::endl;
|
|
debfillw(iW);
|
|
}
|
|
GLOBAL_iexE = 0;
|
|
#endif
|
|
|
|
TopOpeBRepTool_ShapeExplorer exEdge(W,TopAbs_EDGE);
|
|
for (; exEdge.More(); exEdge.Next()) {
|
|
const TopoDS_Shape& EOR = exEdge.Current();
|
|
|
|
#ifdef OCCT_DEBUG
|
|
GLOBAL_iexE++;
|
|
if (tSPS) {
|
|
// const TopoDS_Edge& ed = TopoDS::Edge(EOR);
|
|
// Standard_Boolean isdegen = BRep_Tool::Degenerated(ed);
|
|
// TopLoc_Location L;
|
|
// Handle(Geom_Surface) S = BRep_Tool::Surface(myFaceToFill,L);
|
|
// Standard_Boolean isclosed = BRep_Tool::IsClosed(ed,S,L);
|
|
// TopAbs_Orientation oried = ed.Orientation();
|
|
// Standard_Boolean trc = Standard_False;
|
|
#ifdef DRAW
|
|
// if (trc) {FUN_draw(ed); FUN_draw2de(ed,myFaceReference);}
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
GFillEdgeWES(EOR,LSclass,G1,WES);
|
|
}
|
|
} // GFillWireWES
|
|
|
|
|
|
//=======================================================================
|
|
//function : GFillEdgeWES
|
|
//purpose :
|
|
//=======================================================================
|
|
void TopOpeBRepBuild_Builder::GFillEdgeWES(const TopoDS_Shape& EOR,
|
|
const TopTools_ListOfShape& LSclass,
|
|
const TopOpeBRepBuild_GTopo& G1,
|
|
TopOpeBRepBuild_WireEdgeSet& WES)
|
|
{
|
|
TopAbs_State TB1,TB2; G1.StatesON(TB1,TB2);
|
|
|
|
#ifdef OCCT_DEBUG
|
|
Standard_Integer iE; Standard_Boolean tSPS = GtraceSPS(EOR,iE);
|
|
if(tSPS)std::cout<<std::endl;
|
|
#endif
|
|
|
|
#ifdef OCCT_DEBUG
|
|
Standard_Boolean tosplit =
|
|
#endif
|
|
GToSplit(EOR,TB1);
|
|
#ifdef OCCT_DEBUG
|
|
Standard_Boolean tomerge =
|
|
#endif
|
|
GToMerge(EOR);
|
|
|
|
#ifdef OCCT_DEBUG
|
|
if(tSPS) GdumpSHASTA(iE,TB1,WES,"--- GFillEdgeWES ");
|
|
if(tSPS) std::cout<<" tosplit "<<tosplit<<" tomerge "<<tomerge<<std::endl;
|
|
if(tSPS) debfille(iE);
|
|
#endif
|
|
|
|
const TopOpeBRepBuild_GTopo& GME = G1;
|
|
GMergeEdgeWES(EOR,GME,WES);
|
|
|
|
TopOpeBRepBuild_GTopo GSE = G1;
|
|
GSE.ChangeConfig(TopOpeBRepDS_UNSHGEOMETRY,TopOpeBRepDS_UNSHGEOMETRY);
|
|
GSplitEdgeWES(EOR,LSclass,GSE,WES);
|
|
|
|
} // GFillEdgeWES
|
|
|
|
static void FUN_samgeomori(const TopOpeBRepDS_DataStructure& BDS, const Standard_Integer iref, const Standard_Integer ifil,
|
|
Standard_Boolean& samgeomori)
|
|
{
|
|
TopOpeBRepDS_Config cfill = BDS.SameDomainOri(ifil);
|
|
TopAbs_Orientation oref=BDS.Shape(iref).Orientation(), ofil=BDS.Shape(ifil).Orientation();
|
|
samgeomori = (cfill == TopOpeBRepDS_SAMEORIENTED);
|
|
if (oref == TopAbs::Complement(ofil)) samgeomori = !samgeomori;
|
|
}
|
|
|
|
#define UNKNOWN (0)
|
|
#define ONSAMESHA (1)
|
|
#define CLOSESAME (11)
|
|
#define ONOPPOSHA (2)
|
|
#define CLOSEOPPO (22)
|
|
#define FORREVOPPO (222)
|
|
|
|
//=======================================================================
|
|
//function : GSplitEdgeWES
|
|
//purpose :
|
|
//=======================================================================
|
|
void TopOpeBRepBuild_Builder::GSplitEdgeWES(const TopoDS_Shape& EOR,
|
|
const TopTools_ListOfShape& LSclass,
|
|
const TopOpeBRepBuild_GTopo& G1,
|
|
TopOpeBRepBuild_WireEdgeSet& WES)
|
|
{
|
|
TopAbs_State TB1,TB2; G1.StatesON(TB1,TB2);
|
|
Standard_Boolean RevOri1 = G1.IsToReverse1();
|
|
TopAbs_Orientation oriE = EOR.Orientation();
|
|
TopAbs_Orientation neworiE = Orient(oriE,RevOri1);
|
|
const TopOpeBRepDS_DataStructure& BDS = myDataStructure->DS();
|
|
|
|
TopAbs_Orientation oEinF;
|
|
Standard_Integer Oinref = 0;
|
|
Standard_Boolean hsdm = myDataStructure->HasSameDomain(myFaceToFill);
|
|
Standard_Boolean hsdmE = myDataStructure->HasSameDomain(EOR);
|
|
Standard_Integer ifil = myDataStructure->Shape(myFaceToFill);
|
|
Standard_Integer iref = myDataStructure->Shape(myFaceReference);
|
|
if (hsdm) {
|
|
Oinref = FUN_ds_oriEinF(BDS,TopoDS::Edge(EOR),myFaceReference,oEinF); //xpu060598
|
|
|
|
// xpu150998 : cto900P6 : e35ou added to fref34,f53, oEinF=REVERSED, oEinfill=FORWARD
|
|
TopAbs_Orientation oEinfill;
|
|
Standard_Integer Oinfill = FUN_ds_oriEinF(BDS,TopoDS::Edge(EOR),myFaceToFill,oEinfill);
|
|
if (Oinref == Oinfill) {
|
|
|
|
Standard_Boolean reverse = Standard_False;
|
|
if (iref != ifil) {
|
|
// xpu230299 : FRA60275 (e6,fref4,ffill7) + PRO16297
|
|
TopAbs_Orientation oref = myFaceReference.Orientation();
|
|
Standard_Boolean samegeomori; FUN_samgeomori(BDS,iref,ifil,samegeomori);
|
|
reverse = (!samegeomori);
|
|
if (oref == TopAbs_REVERSED) reverse = !reverse;
|
|
}
|
|
// TopAbs_Orientation oref=myFaceReference.Orientation(), ofill=myFaceToFill.Orientation();
|
|
// Standard_Boolean reverse = (oref != ofill);
|
|
|
|
TopAbs_Orientation oEinfillTOref = reverse ? TopAbs::Complement(oEinfill) : oEinfill;
|
|
Standard_Boolean same = (oEinF == oEinfillTOref);
|
|
if (!same && (oEinF!=TopAbs_INTERNAL) && (oEinF!=TopAbs_EXTERNAL)) oEinF = oEinfillTOref;
|
|
}
|
|
}
|
|
else Oinref = FUN_ds_oriEinF(BDS,TopoDS::Edge(EOR),myFaceToFill,oEinF); //xpu060598
|
|
Standard_Boolean newO = (Oinref == ONSAMESHA) || (Oinref == ONOPPOSHA); //xpu060598
|
|
|
|
Standard_Boolean isfafa = (myIsKPart == 3);
|
|
if (isfafa) newO = Standard_False;// xpu110598
|
|
|
|
// if (fus) : faces are SDSO : we keep original edge's orientation
|
|
// if (com) : faces are SDSO : we keep original edge's orientation
|
|
// if (cut && TBToFill==OUT) : myFaceToFill is the reference face,
|
|
// we keep original edge's orientation
|
|
|
|
#ifdef OCCT_DEBUG
|
|
Standard_Integer iEOR; Standard_Boolean tSPS = GtraceSPS(EOR,iEOR);
|
|
Standard_Integer iWESF; /*Standard_Boolean tSPSW = */GtraceSPS(WES.Face(),iWESF);
|
|
if(tSPS) GdumpSHASTA(iEOR,TB1,WES,"\n--- GSplitEdgeWES","START");
|
|
if(tSPS) std::cout<<" RevOri1 : "<<RevOri1<<std::endl;
|
|
if(tSPS) debsplite(iEOR);
|
|
#endif
|
|
|
|
Standard_Boolean tosplit = GToSplit(EOR,TB1);
|
|
if (tosplit) {
|
|
GSplitEdge(EOR,G1,LSclass);
|
|
//modified by NIZNHY-PKV Mon Mar 19 16:53:40 2001 f
|
|
if (myIsKPart==4) {
|
|
// Only solids are available here
|
|
TopAbs_State aState;
|
|
Standard_Integer aRank1;
|
|
TopTools_ListOfShape anAuxList;
|
|
|
|
aRank1=ShapeRank(EOR);
|
|
const TopoDS_Shape& aSolid=(aRank1==1) ? myShape2 : myShape1;
|
|
|
|
TopTools_ListOfShape& aSplitList = ChangeSplit (EOR, TB1);
|
|
TopTools_ListIteratorOfListOfShape anIt(aSplitList);
|
|
for (; anIt.More(); anIt.Next()) {
|
|
const TopoDS_Edge& aSplitEdge=TopoDS::Edge (anIt.Value());
|
|
aState=ClassifyEdgeToSolidByOnePoint (aSplitEdge, aSolid);
|
|
if (aState==TB1) {
|
|
anAuxList.Append (aSplitEdge);
|
|
}
|
|
}
|
|
|
|
aSplitList.Clear();
|
|
|
|
anIt.Initialize(anAuxList);
|
|
for (; anIt.More(); anIt.Next()) {
|
|
const TopoDS_Shape& aShape=anIt.Value();
|
|
aSplitList.Append(aShape);
|
|
}
|
|
}
|
|
//modified by NIZNHY-PKV Mon Mar 19 16:53:44 2001 t
|
|
}
|
|
|
|
//xpu200598 : never add spIN in fusion
|
|
Standard_Boolean opeFus = Opefus(); //xpu200598
|
|
if (opeFus) //xpu200598
|
|
if (TB1 == TopAbs_IN) return; //xpu200598
|
|
|
|
Standard_Boolean issplit = IsSplit(EOR,TB1);
|
|
if ( issplit ) {
|
|
const TopTools_ListOfShape& LSE = Splits(EOR,TB1);
|
|
|
|
#ifdef OCCT_DEBUG
|
|
if(tSPS) {
|
|
GdumpSHASTA(iEOR,TB1,WES,"--- GSplitEdgeWES","WES+ Split");
|
|
std::cout<<" ";TopAbs::Print(TB1,std::cout)<<" : "<<LSE.Extent()<<" edge(s) ";
|
|
TopAbs::Print(neworiE,std::cout); std::cout<<std::endl;
|
|
}
|
|
#endif
|
|
|
|
for (TopTools_ListIteratorOfListOfShape it(LSE);
|
|
it.More(); it.Next()) {
|
|
TopoDS_Edge newE = TopoDS::Edge(it.Value());
|
|
if (newO) {// xpu060598
|
|
// PRO13075 tspIN(f18), tspIN(e17)
|
|
// we add sp(EOR) to myFaceToFill with its orientation
|
|
newE.Orientation(oEinF);
|
|
Standard_Boolean dgE = BRep_Tool::Degenerated(TopoDS::Edge(EOR));
|
|
if (!dgE && hsdmE) {
|
|
Standard_Real f,l; FUN_tool_bounds(newE,f,l);
|
|
Standard_Real x = 0.45678; Standard_Real par = (1-x)*f + x*l;
|
|
Standard_Boolean so = Standard_True;
|
|
Standard_Boolean ok = FUN_tool_curvesSO(newE,par,TopoDS::Edge(EOR),so);
|
|
if (!ok) {
|
|
#ifdef OCCT_DEBUG
|
|
std::cout<<"GSplitEdgeWES: cannot orient SDM split of an edge"<<std::endl;
|
|
#endif
|
|
//return; // nyiFUNRAISE
|
|
}
|
|
if (!so) {
|
|
newE.Reverse();
|
|
}
|
|
} //!dgE && hsdmE
|
|
}// xpu060598
|
|
else newE.Orientation(neworiE);
|
|
|
|
#ifdef OCCT_DEBUG
|
|
if (tSPS) debaddpwes(iWESF,TB1,iEOR,neworiE,(TopOpeBRepBuild_Builder* const)this,&WES,"GSplitEdgeWES " ,"WES+ Eisspl ");
|
|
#endif
|
|
|
|
WES.AddStartElement(newE);
|
|
}
|
|
} // issplit
|
|
|
|
else {
|
|
// EOR sans devenir de Split par TB1 : on la garde si elle est situee TB1 / LSclass
|
|
Standard_Boolean se = BDS.IsSectionEdge(TopoDS::Edge(EOR));
|
|
Standard_Boolean hs = myDataStructure->HasShape(EOR);
|
|
Standard_Boolean hg = myDataStructure->HasGeometry(EOR);
|
|
Standard_Boolean add = Standard_False;
|
|
Standard_Boolean addON = Standard_False;
|
|
|
|
Standard_Boolean isstart = Standard_False;
|
|
isstart = hs;
|
|
|
|
if (se) {
|
|
Standard_Boolean ftg = !LSclass.IsEmpty();
|
|
TopAbs_ShapeEnum tclass = LSclass.First().ShapeType();
|
|
ftg = ftg && (tclass == TopAbs_FACE);
|
|
if (!ftg) {
|
|
TopAbs_State pos;
|
|
Standard_Boolean keepse = GKeepShape1(EOR,LSclass,TB1,pos);
|
|
if (keepse)
|
|
add = Standard_True;
|
|
else if (myProcessON && pos == TopAbs_ON)
|
|
addON = Standard_True;
|
|
}
|
|
|
|
#ifdef OCCT_DEBUG
|
|
std::cout<<"o-o GridFF ffil F"<<ifil<<" se E"<<iEOR<<" / "<<iWESF<<" ";
|
|
TopAbs::Print(TB1,std::cout);std::cout.flush();
|
|
if (!ftg) {std::cout<<" : !ftg --> "; GKeepShape(EOR,LSclass,TB1);std::cout.flush();}
|
|
else {std::cout<<" : ftg --> non gardee"<<std::endl;std::cout.flush();}
|
|
#endif
|
|
|
|
}
|
|
else {
|
|
add = Standard_True;
|
|
Standard_Boolean testkeep = Standard_True;
|
|
testkeep = hs && (!hg);
|
|
if (testkeep) {
|
|
#ifdef OCCT_DEBUG
|
|
if(tSPS){std::cout<<"--- GSplitEdgeWES ";}
|
|
#endif
|
|
TopAbs_State pos;
|
|
Standard_Boolean keep = GKeepShape1(EOR,LSclass,TB1,pos);
|
|
if ( !keep ) {
|
|
Standard_Boolean testON = (!LSclass.IsEmpty());
|
|
if (testON) testON = (LSclass.First().ShapeType() == TopAbs_SOLID);
|
|
if (testON) keep = (pos == TopAbs_ON);
|
|
addON = myProcessON && keep;
|
|
}
|
|
add = keep;
|
|
}
|
|
} // !se
|
|
|
|
if (add) {
|
|
TopoDS_Shape newE = EOR;
|
|
|
|
if (newO) newE.Orientation(oEinF);// xpu060598
|
|
else if (Oinref == FORREVOPPO) newE.Orientation(TopAbs_INTERNAL);// xpu120898 (PRO14785 : e36 shared by f34 & f39,
|
|
// faces sdm with f16)
|
|
else newE.Orientation(neworiE);
|
|
#ifdef OCCT_DEBUG
|
|
if(tSPS){
|
|
DEBSHASET(ss,"--- GSplitEdgeWES ",WES," WES+ edge ");
|
|
GdumpSHA(newE,(Standard_Address)ss.ToCString());
|
|
std::cout<<" ";TopAbs::Print(TB1,std::cout)<<" : 1 edge ";
|
|
TopAbs::Print(neworiE,std::cout); std::cout<<std::endl;
|
|
}
|
|
#endif
|
|
|
|
if (isstart) {
|
|
#ifdef OCCT_DEBUG
|
|
if (tSPS) debaddpwes(iWESF,TB1,iEOR,neworiE,(TopOpeBRepBuild_Builder* const)this,&WES,"GSplitEdgeWES " ,"WES+ Enospl ");
|
|
#endif
|
|
WES.AddStartElement(newE);
|
|
}
|
|
else {
|
|
WES.AddElement(newE);
|
|
}
|
|
} // add
|
|
|
|
if (addON) {
|
|
TopoDS_Shape newE = EOR;
|
|
newE.Orientation(neworiE);
|
|
myONElemMap.Add(newE);
|
|
}
|
|
} // !issplit
|
|
|
|
if (myProcessON && IsSplit(EOR,TopAbs_ON)) {
|
|
const TopTools_ListOfShape& LSE = Splits(EOR,TopAbs_ON);
|
|
TopTools_ListIteratorOfListOfShape it(LSE);
|
|
for (; it.More(); it.Next()) {
|
|
TopoDS_Edge newE = TopoDS::Edge(it.Value());
|
|
if (newO) {
|
|
newE.Orientation(oEinF);
|
|
Standard_Boolean dgE = BRep_Tool::Degenerated(TopoDS::Edge(EOR));
|
|
if (!dgE && hsdmE) {
|
|
Standard_Real f,l; FUN_tool_bounds(newE,f,l);
|
|
Standard_Real x = 0.45678; Standard_Real par = (1-x)*f + x*l;
|
|
Standard_Boolean so = Standard_True;
|
|
Standard_Boolean ok = FUN_tool_curvesSO(newE,par,TopoDS::Edge(EOR),so);
|
|
if (!ok) {
|
|
#ifdef OCCT_DEBUG
|
|
std::cout<<"GSplitEdgeWES: cannot orient SDM split of an edge"<<std::endl;
|
|
#endif
|
|
}
|
|
if (!so) newE.Reverse();
|
|
}
|
|
}
|
|
else newE.Orientation(neworiE);
|
|
myONElemMap.Add(newE);
|
|
}
|
|
}
|
|
|
|
#ifdef OCCT_DEBUG
|
|
if(tSPS) GdumpSHASTA(iEOR,TB1,WES,"--- GSplitEdgeWES","END");
|
|
#endif
|
|
|
|
return;
|
|
} // GSplitEdgeWES
|
|
|
|
Standard_IMPORT Standard_Boolean FUN_ismotheropedef();
|
|
Standard_IMPORT const TopOpeBRepBuild_GTopo& FUN_motherope();
|
|
Standard_EXPORT Standard_Boolean GLOBAL_IEtoMERGE = 0; // xpu240498
|
|
|
|
#ifdef OCCT_DEBUG
|
|
void debmergee(const Standard_Integer /*i*/) {}
|
|
#endif
|
|
|
|
//=======================================================================
|
|
//function : GMergeEdgeWES
|
|
//purpose :
|
|
//=======================================================================
|
|
void TopOpeBRepBuild_Builder::GMergeEdgeWES(const TopoDS_Shape& EOR,
|
|
const TopOpeBRepBuild_GTopo& G1,
|
|
TopOpeBRepBuild_WireEdgeSet& WES)
|
|
{
|
|
#ifdef OCCT_DEBUG
|
|
Standard_Integer iWESF; /*Standard_Boolean tSPSW = */GtraceSPS(WES.Face(),iWESF);
|
|
Standard_Integer iEOR; Standard_Boolean tSPS = GtraceSPS(EOR,iEOR);
|
|
if(tSPS){ debmergee(iEOR);
|
|
DEBSHASET(s,"\n--- GMergeEdgeWES ",WES," START ");
|
|
GdumpSHAORIGEO(EOR,(Standard_Address)s.ToCString()); std::cout<<std::endl;
|
|
}
|
|
#endif
|
|
|
|
Standard_Boolean closing = BRep_Tool::IsClosed(TopoDS::Edge(EOR),myFaceToFill); // xpu050598
|
|
if (closing) return; // xpu050598
|
|
|
|
if (Opefus()) return;
|
|
|
|
// const TopOpeBRepDS_DataStructure& BDS = myDataStructure->DS();
|
|
TopAbs_State TB1,TB2; G1.StatesON(TB1,TB2);
|
|
Standard_Boolean RevOri1 = G1.IsToReverse1();
|
|
TopAbs_Orientation oriE = EOR.Orientation();
|
|
TopAbs_Orientation neworiE = Orient(oriE,RevOri1);
|
|
|
|
Standard_Boolean hassame = myDataStructure->HasSameDomain(EOR);
|
|
if (!hassame) return;
|
|
|
|
Standard_Boolean Eisref = Standard_False;
|
|
if (hassame) {
|
|
Standard_Integer iEref = myDataStructure->SameDomainReference(EOR);
|
|
const TopoDS_Shape& Eref = myDataStructure->Shape(iEref);
|
|
Eisref = EOR.IsSame(Eref);
|
|
}
|
|
|
|
TopAbs_State TBEOR = (Eisref) ? TB1 : TB2;
|
|
if (TBEOR == TopAbs_OUT) return; //xpu040598
|
|
|
|
Standard_Boolean ismerged = IsMerged(EOR,TBEOR);
|
|
if (ismerged) {
|
|
if (!Eisref) return;
|
|
|
|
const TopTools_ListOfShape& ME = Merged(EOR,TBEOR);
|
|
TopTools_ListIteratorOfListOfShape it(ME);
|
|
for(; it.More(); it.Next()) {
|
|
TopoDS_Shape newE = it.Value();
|
|
newE.Orientation(neworiE);
|
|
|
|
#ifdef OCCT_DEBUG
|
|
if (tSPS) debaddpwes(iWESF,TB1,iEOR,neworiE,(TopOpeBRepBuild_Builder* const)this,&WES,"GMergeEdgeWES " ,"WES+ Emerge ");
|
|
#endif
|
|
|
|
WES.AddStartElement(newE);
|
|
}
|
|
return;
|
|
}
|
|
|
|
ChangeMerged(EOR,TBEOR) = myEmptyShapeList;
|
|
TopAbs_State stspEOR;
|
|
// if (isfafa) stspEOR = TBEOR; // xpu110598
|
|
// else stspEOR = (TBEOR == TopAbs_IN) ? TopAbs_ON : TopAbs_OUT;
|
|
stspEOR = TBEOR; // xpu120598
|
|
|
|
Standard_Boolean issplit = IsSplit(EOR,stspEOR);
|
|
if (!issplit) return;
|
|
|
|
ChangeMerged(EOR,TBEOR) = Splits(EOR,stspEOR);
|
|
|
|
const TopTools_ListOfShape& ME = Merged(EOR,TBEOR);
|
|
#ifdef OCCT_DEBUG
|
|
if(tSPS){
|
|
DEBSHASET(s,"GMergeEdgeWES(1) ",WES," WES+ Merged ");
|
|
GdumpSHA(EOR,(Standard_Address)s.ToCString());
|
|
std::cout<<" ";TopAbs::Print(TBEOR,std::cout);
|
|
std::cout<<" : "<<ME.Extent()<<" edge"<<std::endl;
|
|
}
|
|
#endif
|
|
for(TopTools_ListIteratorOfListOfShape it(ME);it.More();it.Next()) {
|
|
TopoDS_Shape newE = it.Value();
|
|
newE.Orientation(neworiE);
|
|
WES.AddStartElement(newE);
|
|
}
|
|
|
|
#ifdef OCCT_DEBUG
|
|
if(tSPS){
|
|
DEBSHASET(sss,"GMergeEdgeWES ",WES," END ");
|
|
GdumpSHA(EOR,(Standard_Address)sss.ToCString());std::cout<<std::endl;
|
|
}
|
|
#endif
|
|
|
|
} // GMergeEdgeWES
|
|
|
|
//=======================================================================
|
|
//function : GSplitEdge
|
|
//purpose :
|
|
//=======================================================================
|
|
void TopOpeBRepBuild_Builder::GSplitEdge(const TopoDS_Shape& EOR,
|
|
const TopOpeBRepBuild_GTopo& G1,
|
|
const TopTools_ListOfShape& LSclass)
|
|
{
|
|
TopAbs_ShapeEnum t1,t2;
|
|
G1.Type(t1,t2);
|
|
TopAbs_State TB1,TB2; G1.StatesON(TB1,TB2);
|
|
// work on a FORWARD edge <EF>
|
|
TopoDS_Shape EF = EOR; EF.Orientation(TopAbs_FORWARD);
|
|
|
|
#ifdef OCCT_DEBUG
|
|
Standard_Integer iE; Standard_Boolean tSPS = GtraceSPS(EOR,iE);
|
|
if (tSPS) GdumpSHASTA(EOR,TB1,"--- GSplitEdge ","\n");
|
|
if (tSPS) GdumpEDG(EF);
|
|
if (tSPS) debsplite(iE);
|
|
#endif
|
|
|
|
const TopoDS_Edge& EEF = TopoDS::Edge(EF);
|
|
Standard_Boolean isse = myDataStructure->DS().IsSectionEdge(EEF);
|
|
Standard_Boolean issplitON = IsSplit(EEF,TopAbs_ON);
|
|
Standard_Boolean takeON = (TB1 == TopAbs_IN) && (isse) && (issplitON);
|
|
takeON = Standard_False;
|
|
#ifdef OCCT_DEBUG
|
|
if (tSPS) std::cout<<"---- takeON mis a 0"<<std::endl;
|
|
#endif
|
|
|
|
if ( takeON ) {
|
|
|
|
#ifdef OCCT_DEBUG
|
|
if (tSPS) GdumpSHASTA(EOR,TB1,"--- GSplitEdge takeON ","\n");
|
|
#endif
|
|
|
|
MarkSplit(EF,TB1);
|
|
TopTools_ListOfShape& SSEL = ChangeSplit(EF,TB1);
|
|
SSEL.Clear();
|
|
SSEL = Splits(EEF,TopAbs_ON);
|
|
return;
|
|
}
|
|
|
|
TopTools_ListOfShape LOE;
|
|
|
|
// Make a PaveSet PVS on edge EF
|
|
TopOpeBRepBuild_PaveSet PVS(EF);
|
|
|
|
// Add the point topology found on edge EF in PVS
|
|
myEdgeReference = TopoDS::Edge(EF);
|
|
GFillPointTopologyPVS(EF,G1,PVS);
|
|
|
|
// mark EF as split TB1
|
|
MarkSplit(EF,TB1);
|
|
|
|
// build the new edges LOE on EF from the Parametrized Vertex set PVS
|
|
GPVSMakeEdges(EF,PVS,LOE);
|
|
|
|
Standard_Boolean novertex = LOE.IsEmpty();
|
|
if (novertex) return;
|
|
|
|
TopTools_ListOfShape& SEL = ChangeSplit(EF,TB1);
|
|
SEL.Clear();
|
|
// NYI ne pas faire de classification des aretes reconstruites / liste de solides
|
|
// NYI dans le cas ou l'appel a SplitEdge est utilise pour construire les parties
|
|
// NYI (TopAbs_ON,SOLID) (i.e par la construction des parties (TopAbs_IN,FACE)).
|
|
TopOpeBRepDS_Config c1 = G1.Config1(),c2 = G1.Config2();
|
|
Standard_Boolean UUFACE = (c1==TopOpeBRepDS_UNSHGEOMETRY && c2==TopOpeBRepDS_UNSHGEOMETRY);
|
|
|
|
Standard_Boolean ONSOLID = Standard_False;
|
|
if ( ! LSclass.IsEmpty() ) {
|
|
TopAbs_ShapeEnum t = LSclass.First().ShapeType();
|
|
ONSOLID = (t == TopAbs_SOLID);
|
|
}
|
|
|
|
Standard_Boolean toclass = UUFACE;
|
|
toclass = ! ONSOLID;
|
|
|
|
TopTools_ListOfShape loos;
|
|
const TopTools_ListOfShape* pls;
|
|
if (GLOBAL_classifysplitedge) {
|
|
Standard_Integer r=GShapeRank(EOR);
|
|
TopoDS_Shape oos=myShape1;
|
|
if (r==1) oos = myShape2;
|
|
if (!oos.IsNull()) loos.Append(oos); // PMN 5/03/99 Nothing to append
|
|
pls = &loos;
|
|
}
|
|
else if (toclass) {
|
|
pls = &LSclass;
|
|
}
|
|
else {
|
|
pls = &myEmptyShapeList;
|
|
}
|
|
|
|
TopTools_ListOfShape aLON;
|
|
TopTools_ListIteratorOfListOfShape it(LOE);
|
|
for(;it.More();it.Next()) {
|
|
const TopoDS_Shape& aE = it.Value();
|
|
TopAbs_State pos;
|
|
if (GKeepShape1(aE,*pls,TB1,pos))
|
|
SEL.Append(aE);
|
|
else if (myProcessON && pos == TopAbs_ON)
|
|
aLON.Append(aE);
|
|
}
|
|
|
|
if (!aLON.IsEmpty()) {
|
|
MarkSplit(EF,TopAbs_ON);
|
|
TopTools_ListOfShape& aSLON = ChangeSplit(EF,TopAbs_ON);
|
|
aSLON.Clear();
|
|
aSLON.Append(aLON);
|
|
}
|
|
|
|
} // GSplitEdge
|
|
|
|
//modified by NIZNHY-PKV Mon Mar 19 16:50:33 2001 f
|
|
#include <BRepClass3d_SolidClassifier.hxx>
|
|
//=======================================================================
|
|
//function : ClassifyEdgeToSolidByOnePoint
|
|
//purpose :
|
|
//=======================================================================
|
|
TopAbs_State ClassifyEdgeToSolidByOnePoint(const TopoDS_Edge& E,
|
|
const TopoDS_Shape& Ref)
|
|
{
|
|
const Standard_Real PAR_T = 0.43213918;//10.*e^-PI
|
|
Standard_Real f2 = 0., l2 = 0., par = 0.;
|
|
|
|
Handle(Geom_Curve) C3D = BRep_Tool::Curve(E, f2, l2);
|
|
gp_Pnt aP3d;
|
|
|
|
if(C3D.IsNull()) {
|
|
//it means that we are in degenerated edge
|
|
const TopoDS_Vertex& fv = TopExp::FirstVertex(E);
|
|
if(fv.IsNull())
|
|
return TopAbs_UNKNOWN;
|
|
aP3d = BRep_Tool::Pnt(fv);
|
|
}
|
|
else {//usual case
|
|
par = f2*PAR_T + (1 - PAR_T)*l2;
|
|
C3D -> D0(par, aP3d);
|
|
}
|
|
|
|
BRepClass3d_SolidClassifier SC(Ref);
|
|
SC.Perform(aP3d, 1e-7);
|
|
|
|
return SC.State();
|
|
}
|
|
//modified by NIZNHY-PKV Mon Mar 19 16:50:36 2001 t
|