0024428: Implementation of LGPL license
[occt.git] / src / BRepAlgo / BRepAlgo_DSAccess.cxx
1 // Created on: 1997-08-13
2 // Created by: Prestataire Mary FABIEN
3 // Copyright (c) 1997-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and / or modify it
9 // under the terms of the GNU Lesser General Public version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17 #include <BRepAlgo_DSAccess.ixx>
18 #include <BRepAlgo_EdgeConnector.hxx>
19
20 #include <TColStd_ListOfInteger.hxx>
21 #include <TColStd_MapOfInteger.hxx>
22 #include <TColStd_IndexedMapOfInteger.hxx>
23 #include <TColStd_MapIteratorOfMapOfInteger.hxx>
24 #include <TColStd_SetIteratorOfSetOfInteger.hxx>
25
26 #include <TopTools_ListOfShape.hxx>
27 #include <TopTools_ListIteratorOfListOfShape.hxx>
28 #include <TopTools_MapOfShape.hxx>
29 #include <TColStd_ListIteratorOfListOfInteger.hxx>
30 #include <TopoDS.hxx>
31 #include <TopoDS_Compound.hxx>
32 #include <TopoDS_Wire.hxx>
33 #include <TopOpeBRepDS_PointIterator.hxx>
34 #include <TopOpeBRepDS_BuildTool.hxx>
35 #include <TopOpeBRepDS_CheckStatus.hxx>
36 #include <TopOpeBRepDS_Check.hxx>
37 #include <TopOpeBRepDS_ListOfInterference.hxx>
38 #include <TopOpeBRepDS_Interference.hxx>
39 #include <TopOpeBRepDS_InterferenceIterator.hxx>
40 #include <TopOpeBRepDS_ListIteratorOfListOfInterference.hxx>
41 #include <TopOpeBRepDS_ShapeShapeInterference.hxx>
42 #include <TopOpeBRepDS_HDataStructure.hxx>
43 #include <TopOpeBRepDS_CurveExplorer.hxx>
44 #include <TopOpeBRepDS_CurveIterator.hxx>
45 #include <TopOpeBRepDS_Filter.hxx>
46 #include <TopOpeBRepDS_Reducer.hxx>
47 #include <TopOpeBRepTool_GeomTool.hxx>
48 #include <TopOpeBRepBuild_HBuilder.hxx>
49 #include <TopOpeBRepBuild_WireEdgeSet.hxx>
50 #include <TopOpeBRepBuild_FaceBuilder.hxx>
51 #include <TopOpeBRep_DSFiller.hxx>
52
53 #ifdef DRAW
54 //#include <TestTopOpe.hxx>
55 #endif
56
57 //=======================================================================
58 //function : Create
59 //purpose  : 
60 //=======================================================================
61
62 BRepAlgo_DSAccess::BRepAlgo_DSAccess() {
63   Init();
64 }
65
66 //=======================================================================
67 //function : Init
68 //purpose  : 
69 //=======================================================================
70
71 void BRepAlgo_DSAccess::Init()
72 {
73   if(myHDS.IsNull()) 
74     myHDS = new TopOpeBRepDS_HDataStructure();
75   else
76     myHDS->ChangeDS().Init();
77   myRecomputeBuilderIsDone = Standard_False;
78   myGetSectionIsDone = Standard_False;
79   myListOfCompoundOfEdgeConnected.Clear();
80   myEC = new BRepAlgo_EdgeConnector();
81   myHB.Nullify();
82   
83   // init of the builder
84   Standard_Real tol3dAPPROX = 1e-7;
85   Standard_Real tol2dAPPROX = 1e-7;
86   // set tolerance values used by the APPROX process
87   TopOpeBRepTool_GeomTool GT;
88   GT.Define(TopOpeBRepTool_APPROX);
89   GT.SetTolerances(tol3dAPPROX,tol2dAPPROX);
90   TopOpeBRepDS_BuildTool BT(GT);
91   myHB = new TopOpeBRepBuild_HBuilder(BT);
92   myHB->ChangeBuilder().ChangeClassify(Standard_False);
93
94   myState1 = TopAbs_UNKNOWN;
95   myState2 = TopAbs_UNKNOWN;
96
97 }
98
99
100 // Filling of the DS
101
102 //=======================================================================
103 //function : Load
104 //purpose  : 
105 //=======================================================================
106
107 void BRepAlgo_DSAccess::Load(const TopoDS_Shape& S)
108 {
109   TopOpeBRepDS_DataStructure& DS = myHDS->ChangeDS();
110   myS1 = S;
111   DS.AddShape(S, 1);
112 }
113
114 //=======================================================================
115 //function : Load
116 //purpose  : 
117 //=======================================================================
118
119 void BRepAlgo_DSAccess::Load(TopoDS_Shape& S1, 
120                              TopoDS_Shape& S2)
121 {
122   TopOpeBRepDS_DataStructure& DS = myHDS->ChangeDS();
123   
124   if ( S1.Orientation() == TopAbs_REVERSED ) {
125     S1.Orientation(TopAbs_FORWARD);
126   }
127   if ( S2.Orientation() == TopAbs_REVERSED ) {
128     S2.Orientation(TopAbs_FORWARD);
129   }
130   
131   DS.AddShape(S1,1);
132   DS.AddShape(S2,2);
133
134   TopOpeBRepTool_ShapeExplorer ex1,ex2;
135   for (ex1.Init(S1,TopAbs_SOLID); ex1.More(); ex1.Next()) {
136     const TopoDS_Shape& so1 = ex1.Current();
137     for (ex2.Init(S2,TopAbs_SOLID); ex2.More(); ex2.Next()) {
138       const TopoDS_Shape& so2 = ex2.Current();
139       DS.FillShapesSameDomain(so1,so2);
140     }
141   }
142   
143   myS1 = S1;
144   myS2 = S2;
145
146 #ifdef DRAW
147 //  TestTopOpe::CurrentDS(myHDS);
148 //  TestTopOpe::Shapes(myS1,myS2);
149 #endif
150 }
151
152 //=======================================================================
153 //function : Intersect
154 //purpose  : 
155 //=======================================================================
156
157 void BRepAlgo_DSAccess::Intersect()
158 {
159   myRecomputeBuilderIsDone = Standard_False;
160   
161   if(!myS1.IsNull() && !myS2.IsNull())
162     myDSFiller.Insert(myS1, myS2, myHDS);
163 }
164
165 //=======================================================================
166 //function : Intersect
167 //purpose  : 
168 //=======================================================================
169
170 void BRepAlgo_DSAccess::Intersect
171 (const TopoDS_Shape& S1,
172  const TopoDS_Shape& S2)
173 {
174   myRecomputeBuilderIsDone = Standard_False;
175   
176   if(S1.IsNull() || S2.IsNull()) {
177     return;
178   }
179   
180   Standard_Boolean orientFORWARD = Standard_False;
181   TopExp_Explorer exp;
182   if(S1.ShapeType() != TopAbs_FACE) {
183     exp.Init(S1, TopAbs_FACE);
184     if(!exp.More())
185       return;
186   }
187   if(S2.ShapeType() != TopAbs_FACE) {
188     exp.Init(S2, TopAbs_FACE);
189     if(!exp.More())
190       return;
191   }
192   myDSFiller.Insert(S1, S2, myHDS, orientFORWARD);
193 }
194
195 //=======================================================================
196 //function : SameDomain
197 //purpose  : 
198 //=======================================================================
199
200 void BRepAlgo_DSAccess::SameDomain
201 (const TopoDS_Shape& S1,
202  const TopoDS_Shape& S2)
203 {
204   myRecomputeBuilderIsDone = Standard_False;
205   
206   if(S1.IsNull() || S2.IsNull())
207     return;
208
209   TopExp_Explorer exp1, exp2;
210     exp1.Init(S1, TopAbs_FACE);
211     if(!exp1.More())
212       return;
213     exp2.Init(S2, TopAbs_FACE);
214     if(!exp2.More())
215       return;
216   
217   myDSFiller.Insert2d(S1, S2, myHDS);
218 }
219
220
221 // Construction of Sections
222
223 #define FindKeep Standard_False
224
225 //=======================================================================
226 //function : GetSectionEdgeSet
227 //purpose  : 
228 //=======================================================================
229
230 const TopTools_ListOfShape& BRepAlgo_DSAccess::GetSectionEdgeSet
231 (const TopoDS_Shape& S1,
232  const TopoDS_Shape& S2)
233 {
234   GetSectionEdgeSet();
235
236   // Check if S1 and S2 contain faces
237   TopExp_Explorer exp1, exp2;
238   exp1.Init(S1, TopAbs_FACE);
239   if(!exp1.More())
240     return myEmptyListOfShape;
241   exp2.Init(S2, TopAbs_FACE);
242   if(!exp2.More())
243     return myEmptyListOfShape;
244   
245   for(exp1.Init(S1, TopAbs_FACE); exp1.More(); exp1.Next()) {
246     if(!myHDS->HasShape(exp1.Current(), FindKeep))
247       return myEmptyListOfShape;
248   }
249   for(exp2.Init(S2, TopAbs_FACE); exp2.More(); exp2.Next())
250     if(!myHDS->HasShape(exp2.Current(), FindKeep))
251       return myEmptyListOfShape;
252   
253   TopOpeBRepDS_DataStructure& DS = myHDS->ChangeDS();
254   TopOpeBRepBuild_Builder& Builder = myHB->ChangeBuilder();
255   
256   // The purpose is to find interferences associated with faces,
257   // edges that come from their Geometry (= Edge || Curve)
258   TopTools_ListOfShape LE;
259   LE.Clear();
260   TopExp_Explorer exp;
261   for(exp1.Init(S1, TopAbs_FACE); exp1.More(); exp1.Next()) {
262     const TopoDS_Shape& F1 = exp1.Current();
263     
264     TopOpeBRepDS_ListOfInterference& lof = DS.ChangeShapeInterferences(F1);
265     TopOpeBRepDS_InterferenceIterator li(lof);
266     li.SupportKind(TopOpeBRepDS_FACE);
267     for(exp2.Init(S2, TopAbs_FACE); exp2.More(); exp2.Next()) {
268       const TopoDS_Shape& F2 = exp2.Current();
269       Standard_Integer si = DS.Shape(F2, FindKeep);
270       li.Support(si);
271       
272       for(; li.More(); li.Next()) {
273         const TopOpeBRepDS_Interference& CurrInt = li.Value();
274         TopOpeBRepDS_Kind gk = CurrInt.GeometryType();
275         Standard_Integer gi = CurrInt.Geometry();
276         const TopoDS_Shape& geosha = DS.Shape(gi, FindKeep);
277         if(gk == TopOpeBRepDS_CURVE) {
278           const TopTools_ListOfShape& lEdge = myHB->NewEdges(gi);
279           LE.Append(lEdge.First());
280         } else {
281           const TopTools_ListOfShape& lEdge = Builder.Splits(geosha, TopAbs_ON);
282           TopTools_ListIteratorOfListOfShape it(lEdge);
283           for(; it.More(); it.Next()) {
284             const TopoDS_Shape& CurrEdge = it.Value();
285             Standard_Integer ipv1, ipv2;
286             TopOpeBRepDS_Kind pvk1, pvk2;
287             PntVtxOnSectEdge(CurrEdge, ipv1, pvk1, ipv2, pvk2);
288             if(pvk1 != TopOpeBRepDS_VERTEX) {
289               ipv1 = 0;
290               if(pvk2 != TopOpeBRepDS_VERTEX) continue;
291             } else {
292               if(pvk2 != TopOpeBRepDS_VERTEX)
293                 ipv2 = 0;
294             }
295             for(exp.Init(F1, TopAbs_VERTEX); exp.More(); exp.Next()) {
296               Standard_Integer iVert = DS.Shape(exp.Current());
297               if(iVert) {
298                 if((iVert == ipv1) || (iVert == ipv2)) {
299                   LE.Append(CurrEdge);
300                   break;
301                 }
302               }
303             }
304           }
305         }
306       }
307     }
308   }
309
310   // find all groups of connected Edges associated to LE
311   TopTools_ListIteratorOfListOfShape ILE;
312   myCurrentList.Clear();
313   TopTools_MapOfShape ME;
314   ME.Clear();
315   TopTools_ListIteratorOfListOfShape ILC;
316   TopExp_Explorer ECE;
317   ILE.Initialize(LE);
318   for(;ILE.More();ILE.Next()) {
319     const TopoDS_Shape& E = ILE.Value();
320     ILC.Initialize(myListOfCompoundOfEdgeConnected);
321     for(;ILC.More();ILC.Next()) {
322       const TopoDS_Shape& Com = ILC.Value();
323       ECE.Init(Com, TopAbs_EDGE);
324       for(;ECE.More();ECE.Next()) {
325         if(ECE.Current().IsSame(E)) {
326           if(!ME.Contains(Com)) {
327             myCurrentList.Append(Com);
328             ME.Add(Com);
329             break;
330           }
331         }
332       }
333     }
334   }
335   
336   return myCurrentList;
337 }
338
339 //=======================================================================
340 //function : GetSectionEdgeSet
341 //purpose  : 
342 //=======================================================================
343
344 const TopTools_ListOfShape& BRepAlgo_DSAccess::GetSectionEdgeSet()
345 {
346   if(!myRecomputeBuilderIsDone) {
347     // it is possible to call the method many times consecutively
348     myHDS->AddAncestors(myS1);
349     // start of lpa modification
350     if (!myS1.IsSame(myS2) && !myS2.IsNull()) {
351       myHDS->AddAncestors(myS2);
352       myHB->Perform(myHDS,myS1,myS2);
353     }
354     else {
355       myHB->Perform(myHDS);
356     }
357     // end of modif lpa
358     myRecomputeBuilderIsDone = Standard_True;
359     myGetSectionIsDone = Standard_False;
360   } 
361   if(myGetSectionIsDone)
362     return myListOfCompoundOfEdgeConnected;
363   myGetSectionIsDone = Standard_True;
364   
365   myListOfCompoundOfEdgeConnected.Clear();
366   
367   // EdgeConnector
368   Handle(BRepAlgo_EdgeConnector) EC = myEC;
369   EC->ClearStartElement();
370   TopTools_MapOfShape ME;
371   ME.Clear();
372   myHB->InitSection();
373   for(; myHB->MoreSection(); myHB->NextSection()) {
374     const TopoDS_Edge& ES = TopoDS::Edge(myHB->CurrentSection());
375     if(ME.Contains(ES)) continue;
376     ME.Add(ES);
377     EC->AddStart(ES);
378   }
379   TopTools_ListOfShape& LW = EC->MakeBlock();
380   
381   // the wires are tranformed into compounds.
382   myCompoundWireMap.Clear();
383   BRep_Builder BB;
384   TopTools_ListIteratorOfListOfShape ILW(LW);
385   TopExp_Explorer Explor;
386   for(;ILW.More();ILW.Next()) {
387       TopoDS_Compound Compound;
388 //POP
389       BB.MakeCompound(Compound);
390 //      BB.MakeCompound(TopoDS::Compound(Compound));
391       Explor.Init(ILW.Value(), TopAbs_EDGE);
392       for(;Explor.More(); Explor.Next()) {
393         BB.Add(Compound, Explor.Current());
394       }
395       myListOfCompoundOfEdgeConnected.Append(Compound);
396       myCompoundWireMap.Bind(Compound,ILW.Value());
397     }
398   return myListOfCompoundOfEdgeConnected;
399 }
400
401 //=======================================================================
402 //function : IsWire
403 //purpose  : 
404 //=======================================================================
405
406 Standard_Boolean BRepAlgo_DSAccess::IsWire(const TopoDS_Shape& S)
407 {
408   Standard_Boolean b = Standard_False;
409   if(myEC->IsDone()) {
410     if (myCompoundWireMap.IsBound(S))
411       b = myEC->IsWire(myCompoundWireMap(S));
412   }
413   return b;
414 }
415
416 //=======================================================================
417 //function : Wire
418 //purpose  : 
419 //=======================================================================
420
421 const TopoDS_Shape& BRepAlgo_DSAccess::Wire(const TopoDS_Shape& S)
422 {
423   if(!IsWire(S)) {
424     myWire.Nullify();
425   }
426   else {
427     BRep_Builder BB;
428     BB.MakeWire(myWire);
429     TopExp_Explorer Explor(S, TopAbs_EDGE);
430     for(;Explor.More(); Explor.Next()) BB.Add(myWire, Explor.Current());
431   }
432   return myWire;
433 }
434
435 //=======================================================================
436 //function : SectionVertex
437 //purpose  : 
438 //=======================================================================
439
440 const TopTools_ListOfShape& BRepAlgo_DSAccess::SectionVertex
441 (const TopoDS_Shape& F,
442  const TopoDS_Shape& E)
443 {
444   TopTools_ListOfShape Result;
445   Result.Clear();
446   if(F.ShapeType() != TopAbs_FACE) return myEmptyListOfShape;
447   if(E.ShapeType() != TopAbs_EDGE) return myEmptyListOfShape;
448   Standard_Integer iF = myHDS->Shape(F), iE = myHDS->Shape(E);
449   if((iF == 0) || (iE == 0)) return myEmptyListOfShape;
450
451   const TopOpeBRepDS_DataStructure& DS = myHDS->DS();
452   const TopOpeBRepDS_ListOfInterference& LI = 
453     DS.ShapeInterferences(E, Standard_False);
454   TopOpeBRepDS_InterferenceIterator II(LI);
455   Standard_Integer goodIndex = 0;
456   TopOpeBRepDS_Kind goodKind;
457   for(;II.More();II.Next()) {
458     Handle(TopOpeBRepDS_Interference)& I = II.Value();
459     const TopOpeBRepDS_Transition& T = I->Transition();
460     if((T.ONAfter() == TopAbs_FACE) &&
461        (T.IndexAfter()  == iF)) {
462       goodKind  = I->GeometryType();
463       goodIndex = I->Geometry();
464       if(goodKind == TopOpeBRepDS_VERTEX)
465         Result.Append(myHDS->Shape(goodIndex));
466       else 
467         if (goodKind == TopOpeBRepDS_POINT)
468           Result.Append(myHB->NewVertex(goodIndex));
469     }
470   }
471   myListOfVertex = Result;
472   return myListOfVertex;
473 }
474
475
476 // Editing of the DS
477
478 //=======================================================================
479 //function : SuppressEdgeSet
480 //purpose  : 
481 //=======================================================================
482
483 void BRepAlgo_DSAccess::SuppressEdgeSet
484 (const TopoDS_Shape& C)
485 {
486   // It is checked if C really is a Coumpound of connected Edges
487
488   myHB->InitExtendedSectionDS();
489 //  myGetSectionIsDone = Standard_False;
490
491   TopTools_ListIteratorOfListOfShape LLS(myListOfCompoundOfEdgeConnected);
492   for(;LLS.More(); LLS.Next())
493     if(C == LLS.Value())
494       break;
495   if(!LLS.More())
496     return;
497   
498   // Cleaning
499   TopoDS_Shape Empty;
500   Empty.Nullify();
501   Suppress(C, Empty);
502   myListOfCompoundOfEdgeConnected.Remove(LLS);
503 }
504
505 //=======================================================================
506 //function : ChangeEdgeSet
507 //purpose  : 
508 //=======================================================================
509
510 void BRepAlgo_DSAccess::ChangeEdgeSet
511 (const TopoDS_Shape& Old, const TopoDS_Shape& New)
512 {
513   // It is checked if Old is a Coumpound of connected Edges
514
515   myHB->InitExtendedSectionDS();
516
517   TopTools_ListIteratorOfListOfShape LLS(myListOfCompoundOfEdgeConnected);
518   for(;LLS.More(); LLS.Next())
519     if(Old == LLS.Value())
520       break;
521   if(!LLS.More())
522     return;
523
524   // The compound of Edges to be rotated is constructed
525   BRep_Builder B;
526   Standard_Boolean Trouve;
527   Standard_Integer iC;
528   TopoDS_Compound C;
529   TopoDS_Edge E;
530   B.MakeCompound(C);
531   TColStd_SetOfInteger RPoint; //The points to be controlled 
532   
533  TopOpeBRepDS_ListIteratorOfListOfInterference iter;
534   TopExp_Explorer exp(Old, TopAbs_EDGE);
535   TopExp_Explorer exp2;
536   for(; exp.More(); exp.Next()) {
537     const TopoDS_Shape& Edge = exp.Current(); 
538     for(exp2.Init(New, TopAbs_EDGE), Trouve=Standard_False;
539         exp2.More() && (!Trouve); exp2.Next()) {
540       E = TopoDS::Edge(exp2.Current());
541       Trouve = E.IsSame(Edge);
542     }
543
544     if (!Trouve) B.Add(C, Edge); // Edge to be removed
545     else if (!E.IsEqual(Edge)) {
546       // It is necessary to change Interferences => take the complement
547       iC = myHB->GetDSCurveFromSectEdge(Edge);
548       if (!iC) {
549 #if DEB
550         cout << "Warning DSAccess: Modifications of Edge are not implemented" << endl;
551 #endif
552       }
553       else {
554         // Complete the interferences Curve/Face
555         Standard_Integer iF;
556         Handle(TopOpeBRepDS_Interference) interf;
557
558         iF = myHB->GetDSFaceFromDSCurve(iC, 1); 
559         TopOpeBRepDS_ListOfInterference& list1 = 
560            myHDS->ChangeDS().ChangeShapeInterferences(iF);
561         for(iter.Initialize(list1); iter.More(); iter.Next()) {
562           interf = iter.Value();
563           if (interf->Geometry() == iC)
564             interf->Transition(interf->Transition().Complement());
565         }
566         iF = myHB->GetDSFaceFromDSCurve(iC, 2); 
567         TopOpeBRepDS_ListOfInterference& list2 = 
568           myHDS->ChangeDS().ChangeShapeInterferences(iF);
569         for(iter.Initialize(list2); iter.More(); iter.Next()) {
570           interf = iter.Value();
571           if (interf->Geometry() == iC)
572             interf->Transition(interf->Transition().Complement());
573         }
574         // The associated points are recorded
575         Standard_Integer ipv1, ipv2;
576         //Standard_Boolean bid; // skl
577         TopOpeBRepDS_Kind k1, k2;       
578         PntVtxOnCurve(iC, ipv1, k1, ipv2, k2);
579         if (ipv1 != 0) /*bid = */RPoint.Add(ipv1); // skl
580         if (ipv2 != 0) /*bid = */RPoint.Add(ipv2); // skl
581       }
582     }
583   }
584
585
586   // Cleaning
587   Suppress(C, New);
588
589   // Is it necessary to invert the Interferences "Edge on Fa"
590   if (!RPoint.IsEmpty()) {
591     const TopOpeBRepDS_DataStructure & DS = myHDS->DS();
592     Standard_Integer iP,iE, nbShape = DS.NbShapes();
593     Handle(TopOpeBRepDS_Interference) interf;
594     for (iE=1; iE<=nbShape; iE++) {
595       if (DS.Shape(iE,0).ShapeType() == TopAbs_EDGE) { 
596         const TopOpeBRepDS_ListOfInterference& List = 
597           myHDS->DS().ShapeInterferences(iE);
598         for(iter.Initialize(List); iter.More(); iter.Next()) {
599           interf = iter.Value();
600           if (interf->GeometryType() == TopOpeBRepDS_POINT) {
601             iP = interf->Geometry();
602             if (RPoint.Contains(iP))
603               interf->Transition(interf->Transition().Complement());
604           }
605         }
606       }
607     }
608   }
609
610   // The old is replaced by new
611   LLS.Value() = New;
612 }
613
614
615 //=======================================================================
616 //function : Remove
617 //purpose  : 
618 //=======================================================================
619
620 void BRepAlgo_DSAccess::Suppress(const TopoDS_Shape& C,
621                                  const TopoDS_Shape& Keep)
622 {
623  TopOpeBRepDS_DataStructure& DS = myHDS->ChangeDS();
624  TopOpeBRepBuild_Builder& Builder = myHB->ChangeBuilder();
625  Standard_Integer i, iC = 0, iF1, iF2,iE1, iE2;
626 // TopOpeBRepDS_ListIteratorOfListOfInterference;
627  TColStd_ListIteratorOfListOfInteger it1, it2;
628
629   //A group of points to be kept is constructed
630  mySetOfKeepPoint.Clear();
631  if (!Keep.IsNull()) {
632    //Standard_Boolean B; // skl
633    Standard_Integer ipv1, ipv2;
634    TopOpeBRepDS_Kind k1, k2;
635    TopExp_Explorer exp(Keep, TopAbs_EDGE);
636    for(; exp.More(); exp.Next()) {
637      const TopoDS_Shape& SectEdge = exp.Current();
638      iC = myHB->GetDSCurveFromSectEdge(SectEdge);
639      if(!iC) 
640        PntVtxOnSectEdge(SectEdge, ipv1, k1, ipv2, k2);
641      else 
642        PntVtxOnCurve(iC, ipv1, k1, ipv2, k2);
643      if (ipv1 != 0) /*B = */mySetOfKeepPoint.Add(ipv1); // skl
644      if (ipv2 != 0) /*B = */mySetOfKeepPoint.Add(ipv2); // skl
645    }
646  }
647
648   // The curves, which generated the the Edges, are found
649   // during the parsing the Edges which come from Edge are found
650   // (= MapOfInteger : ESE)
651   
652   // First, the interferences of support 1d.
653   TopExp_Explorer exp(C, TopAbs_EDGE);
654   for(; exp.More(); exp.Next()) {
655     const TopoDS_Shape& SectEdge = exp.Current();
656     iC = myHB->GetDSCurveFromSectEdge(SectEdge);
657     if(!iC) {
658       // the Edges that come from Edge are processed
659       // the interferences connected with Edges are processed :
660       iE1 = myHB->GetDSEdgeFromSectEdge(SectEdge, 1);
661       iE2 = myHB->GetDSEdgeFromSectEdge(SectEdge, 2);
662       
663       RemoveEdgeInterferences(iE1,iE2,SectEdge);
664       
665       TColStd_ListOfInteger& loi11 = myHB->GetDSFaceFromDSEdge(iE1, 1);
666       TColStd_ListOfInteger& loi12 = myHB->GetDSFaceFromDSEdge(iE1, 2);
667       for(it1.Initialize(loi11); it1.More(); it1.Next()) {
668         iF1 = it1.Value();
669         for(it2.Initialize(loi12); it2.More(); it2.Next()) {
670           iF2 = it2.Value();
671           // similar to the case of SectEdges coming from curve.
672           RemoveEdgeInterferences(iF1,iF2,SectEdge);
673         }
674       }
675       TColStd_ListOfInteger& loi21 = myHB->GetDSFaceFromDSEdge(iE2, 1);
676       TColStd_ListOfInteger& loi22 = myHB->GetDSFaceFromDSEdge(iE2, 2);
677       for(it1.Initialize(loi21); it1.More(); it1.Next()) {
678         iF1 = it1.Value();
679         for(it2.Initialize(loi22); it2.More(); it2.Next()) {
680           iF2 = it2.Value();
681           // similar to the case of  SectEdges coming from curve.
682           RemoveEdgeInterferences(iF1,iF2,SectEdge);
683         }
684       }
685       continue;
686     }    
687     // The Edges that come from Curve are processed
688     iF1 = myHB->GetDSFaceFromDSCurve(iC, 1);
689     iF2 = myHB->GetDSFaceFromDSCurve(iC, 2);
690     
691     RemoveEdgeInterferences(iF1, iF2, iC);
692     DS.ChangeKeepCurve(iC, FindKeep);
693   }
694   
695   // Secondly, the interferences of 2D support.
696   exp.Init(C, TopAbs_EDGE);
697   for(; exp.More(); exp.Next()) {
698     const TopoDS_Shape& SectEdge = exp.Current();
699     iC = myHB->GetDSCurveFromSectEdge(SectEdge);
700     if(!iC) {
701       iE1 = myHB->GetDSEdgeFromSectEdge(SectEdge, 1);
702       iE2 = myHB->GetDSEdgeFromSectEdge(SectEdge, 2);
703       TColStd_ListOfInteger& loi11 = myHB->GetDSFaceFromDSEdge(iE1, 1);
704       TColStd_ListOfInteger& loi12 = myHB->GetDSFaceFromDSEdge(iE1, 2);
705       for(it1.Initialize(loi11); it1.More(); it1.Next()) {
706         iF1 = it1.Value();
707         for(it2.Initialize(loi12); it2.More(); it2.Next()) {
708           iF2 = it2.Value();
709           if(iF1 == iF2)
710             continue;
711           RemoveFaceInterferences(iF1, iF2, iE1, iE2);
712         }
713       }
714       TColStd_ListOfInteger& loi21 = myHB->GetDSFaceFromDSEdge(iE2, 1);
715       TColStd_ListOfInteger& loi22 = myHB->GetDSFaceFromDSEdge(iE2, 2);
716       for(it1.Initialize(loi21); it1.More(); it1.Next()) {
717         iF1 = it1.Value();
718         for(it2.Initialize(loi22); it2.More(); it2.Next()) {
719           iF2 = it2.Value();
720           if(iF1 == iF2)
721             continue;
722           RemoveFaceInterferences(iF1, iF2, iE1, iE2);
723         }
724       }
725     }
726     else {
727       iF1 = myHB->GetDSFaceFromDSCurve(iC, 1);
728       iF2 = myHB->GetDSFaceFromDSCurve(iC, 2);
729       
730       RemoveFaceInterferences(iF1, iF2, iC);
731     }
732   }
733   
734   // Thirdly, RemoveSameDomain is done for the faces that contain all Edges of C,
735   // and are SameDomain and without Geometry.
736   
737   RemoveFaceSameDomain(C);
738   
739   // Fourthly, the faces, that were not concerned, are removed
740   Standard_Integer NbSh = DS.NbShapes();
741   for(i = 1; i <= NbSh; i++) {
742     const TopoDS_Shape& Face = DS.Shape(i);
743     if(Face.IsNull())
744       continue;
745     if((Face.ShapeType() != TopAbs_FACE) || DS.HasGeometry(Face) ||
746        (myHDS->HasSameDomain(Face)))
747       continue;
748     for(exp.Init(Face, TopAbs_EDGE); exp.More(); exp.Next()){
749       const TopoDS_Shape& Edge = exp.Current();
750       if(DS.HasShape(Edge))
751         break;
752     }
753     if(exp.More())
754       continue;
755     DS.ChangeKeepShape(Face, Standard_False);
756   }
757   
758   // Builder.myKPMAPf1f2 is reconstructed
759   Builder.FindIsKPart(); 
760   
761   //  The Edges of section are removed from Builder.mySplitON
762   exp.Init(C, TopAbs_EDGE);
763   for(; exp.More(); exp.Next()) {
764     const TopoDS_Shape& SectE= exp.Current();
765     TopTools_ListOfShape& losob = Builder.ChangeSplit(SectE, TopAbs_ON);
766     losob.Clear();
767   }
768 }
769
770 //=======================================================================
771 //function : SuppressSectionVertex
772 //purpose  : 
773 //=======================================================================
774
775 void BRepAlgo_DSAccess::SuppressSectionVertex
776 (const TopoDS_Vertex& /*V*/)
777 {
778   if(!myRecomputeBuilderIsDone)
779     return;
780 }
781
782
783 // Reconstruction of Shapes
784
785 //=======================================================================
786 //function : Merge
787 //purpose  : 
788 //=======================================================================
789
790 const TopoDS_Shape& BRepAlgo_DSAccess::Merge
791 (const TopAbs_State state1,
792  const TopAbs_State state2)
793 {
794   if((state1 != TopAbs_IN) &&
795      (state1 != TopAbs_OUT))
796     return myEmptyShape;
797   if((state2 != TopAbs_IN) &&
798      (state2 != TopAbs_OUT))
799     return myEmptyShape;
800   // if GetSectionEdgeSet has already been called, nothing is done 
801   // in GetSectionEdgeSet.
802   if(myState1 != TopAbs_UNKNOWN)
803     if(myState1 != state1 || myState2 != state2)
804       myGetSectionIsDone = Standard_False;
805   myState1 = state1;
806   myState2 = state2;
807   GetSectionEdgeSet();
808   
809   myHB->Clear();
810   myHB->MergeShapes(myS1,state1,myS2,state2);
811   const TopTools_ListOfShape& L1 = myHB->Merged(myS1,state1);
812   
813   BRep_Builder BB;
814   myResultShape.Nullify();
815   BB.MakeCompound(TopoDS::Compound(myResultShape));
816   TopTools_ListIteratorOfListOfShape it(L1);
817   for(;it.More(); it.Next()) {
818     BB.Add(myResultShape, it.Value());
819   }
820   return myResultShape;
821 }
822
823 //=======================================================================
824 //function : Merge
825 //purpose  : 
826 //=======================================================================
827
828 const TopoDS_Shape& BRepAlgo_DSAccess::Merge
829 (const TopAbs_State state1)
830 {
831   if((state1 != TopAbs_IN) &&
832      (state1 != TopAbs_OUT))
833     return myEmptyShape;
834   GetSectionEdgeSet();
835
836   myHB->Clear();
837   myHB->MergeSolid(myS1,state1);
838   const TopTools_ListOfShape& L1 = myHB->Merged(myS1,state1);
839   
840   BRep_Builder BB;
841   myResultShape.Nullify();
842   BB.MakeCompound(TopoDS::Compound(myResultShape));
843   TopTools_ListIteratorOfListOfShape it(L1);
844   for(;it.More(); it.Next()) {
845     BB.Add(myResultShape, it.Value());
846   }
847   return myResultShape;
848 }
849
850 //=======================================================================
851 //function : Propagate
852 //purpose  : 
853 //=======================================================================
854
855 const TopoDS_Shape& BRepAlgo_DSAccess::Propagate
856 (const TopAbs_State what,
857  const TopoDS_Shape& /*fromShape*/,
858  const TopoDS_Shape& /*LoadShape*/)
859 {
860   if((what != TopAbs_IN) &&
861      (what != TopAbs_OUT))
862     return myEmptyShape;
863   if(!myRecomputeBuilderIsDone)
864     return myEmptyShape;
865
866 //  myHB->MergeShapes(myS1,t1,myS2,t2);
867
868   //POP for NT;
869   static TopoDS_Shape bid;
870   return bid;
871 }
872
873 //=======================================================================
874 //function : PropagateFromSection
875 //purpose  : 
876 //=======================================================================
877
878 const TopoDS_Shape& BRepAlgo_DSAccess::PropagateFromSection
879 (const TopoDS_Shape& SectionShape)
880 {
881   GetSectionEdgeSet();
882   TopTools_ListIteratorOfListOfShape ils(myListOfCompoundOfEdgeConnected);
883   TopExp_Explorer exp;
884   for(; ils.More(); ils.Next()) {
885     const TopoDS_Shape& SetEdgSet = ils.Value();
886     exp.Init(SetEdgSet, TopAbs_EDGE);
887     for(; exp.More(); exp.Next()) {
888       if(SectionShape.IsSame(exp.Current()))
889         return SetEdgSet;
890     }
891   }
892   return myEmptyShape;
893 }
894
895 //=======================================================================
896 //function : Modified
897 //purpose  : 
898 //=======================================================================
899
900 const TopTools_ListOfShape& BRepAlgo_DSAccess::Modified (const TopoDS_Shape& Shape) 
901 {
902   myModified.Clear() ;
903
904 //  Handle(TopOpeBRepBuild_HBuilder)& HBuilder = myDSA.myHB ;
905   TopTools_ListIteratorOfListOfShape Iterator ;
906   
907   if (myHB->IsSplit (Shape, TopAbs_OUT)) {
908     for (Iterator.Initialize (myHB->Splits (Shape, TopAbs_OUT)) ;
909          Iterator.More() ;
910          Iterator.Next()) {
911       myModified.Append (Iterator.Value()) ;
912     }
913   }
914   if (myHB->IsSplit (Shape, TopAbs_IN)) {
915     for (Iterator.Initialize (myHB->Splits (Shape, TopAbs_IN)) ;
916          Iterator.More() ;
917          Iterator.Next()) {
918       myModified.Append (Iterator.Value()) ;
919     }
920   }
921   if (myHB->IsSplit (Shape, TopAbs_ON)) {
922     for (Iterator.Initialize (myHB->Splits (Shape, TopAbs_ON)) ;
923          Iterator.More() ;
924          Iterator.Next()) {
925       myModified.Append (Iterator.Value()) ;
926     }
927   }
928
929   if (myHB->IsMerged (Shape, TopAbs_OUT)) {
930     for (Iterator.Initialize (myHB->Merged (Shape, TopAbs_OUT)) ;
931          Iterator.More() ;
932          Iterator.Next()) {
933       myModified.Append (Iterator.Value()) ;
934     }
935   }
936   if (myHB->IsMerged(Shape, TopAbs_IN)) {
937     for (Iterator.Initialize (myHB->Merged (Shape, TopAbs_IN)) ;
938          Iterator.More() ;
939          Iterator.Next()) {
940       myModified.Append (Iterator.Value()) ;
941     }
942   }
943   if (myHB->IsMerged(Shape, TopAbs_ON)) {
944     for (Iterator.Initialize (myHB->Merged (Shape, TopAbs_ON)) ;
945          Iterator.More() ;
946          Iterator.Next()) {
947       myModified.Append (Iterator.Value()) ;
948     }
949   }
950
951   return myModified ;
952 }
953
954
955
956 //=======================================================================
957 //function : Check
958 //purpose  : 
959 //=======================================================================
960
961 BRepAlgo_CheckStatus BRepAlgo_DSAccess::Check()
962 {
963 //  TopOpeBRepDS_Check Ck(HDS);
964 // to be precised : in Ck, there is a possibility to know 
965 // exactly the n*n of shapes/points/curves/surfaces, 
966 // which are not correct in the DS.
967 //  Standard_Boolean IsOK = Ck.ChkIntgSamDom() ;
968 //  IsOK = IsOK && Ck.OneVertexOnPnt();
969 //  IsOK = IsOK && Ck.ChkIntg();
970 //  if(IsOK)
971 //    return TopOpeBRepDS_OK;
972   return BRepAlgo_NOK;
973 }
974
975 //=======================================================================
976 //function : RemoveEdgeInterferences
977 //purpose  : case of SectEdge coming from Edge(s)
978 //       
979 //     if iE1 and iE2 are Edges :
980 //     Remove interferences of DSEdge(= iE1 or iE2) of
981 //     geometry a vertex of SectEdge, and if there is nothing else, 
982 //     make unkeep on DSEdge 
983 //     if iE1 or iE2 == 0, no interference on Edges in the DS 
984 //     NYI : management of SameDomain
985 //       
986 //     if iE1 and iE2 are Faces :
987 //     for each of faces F1 and F2, explode into Edges
988 //     for each Edge :
989 //           remove the interferences of a SectEdge vertex
990 //           on geometry. If there is no other interferences attached to 
991 //           these Edges, and if these Edges are not SameDomain,
992 //           make unKeepShape.
993 //=======================================================================
994
995 void BRepAlgo_DSAccess::RemoveEdgeInterferences
996 (const Standard_Integer iE1,
997  const Standard_Integer iE2,
998  const TopoDS_Shape& SectEdge)
999 {
1000   if(!iE1 || !iE2)
1001     return;
1002
1003   TopOpeBRepDS_DataStructure& DS = myHDS->ChangeDS();
1004   TopOpeBRepDS_Kind kind1, kind2;
1005   TopExp_Explorer exp(SectEdge, TopAbs_VERTEX);
1006   Standard_Integer i = 1, ipv1, ipv2;
1007   
1008   // the Vertex/Points of SectEdge are retrieved
1009   PntVtxOnSectEdge(SectEdge, ipv1, kind1, ipv2, kind2);
1010   
1011   const TopoDS_Shape& Shape = DS.Shape(iE1, FindKeep);
1012   if(Shape.IsNull())
1013     return;
1014   if(Shape.ShapeType() == TopAbs_FACE) {
1015     Standard_Integer iF1 = iE1, iF2 = iE2;
1016     RemoveEdgeInterferencesFromFace(iF1, iF2, ipv1, kind1, ipv2, kind2);
1017     return;
1018   }
1019   else if(Shape.ShapeType() != TopAbs_EDGE)
1020     return;
1021   
1022   // the interferences are taken from the DS
1023   TopOpeBRepDS_ListIteratorOfListOfInterference lioloi;
1024   TopOpeBRepDS_Kind gk;
1025   Standard_Integer iCurrE1, iCurrE2, gi;
1026 //  Standard_Boolean RemInterf;
1027   
1028   for(i = 1; i <= 2; i++) {
1029     iCurrE1 = ((i == 1) ? iE1 : iE2);
1030     iCurrE2 = ((i == 1) ? iE2 : iE1);
1031     const TopoDS_Shape& DSEdge = DS.Shape(iCurrE1, FindKeep);
1032     if(DSEdge.IsNull())
1033       continue;
1034     TopOpeBRepDS_ListOfInterference& loi = 
1035       DS.ChangeShapeInterferences(DSEdge);
1036     //    RemInterf = Standard_True;
1037     for(lioloi.Initialize(loi); lioloi.More(); lioloi.Next()) {
1038       Handle(TopOpeBRepDS_Interference) I = lioloi.Value();
1039       if (I.IsNull()) continue;
1040       if((I->SupportType() != TopOpeBRepDS_EDGE) ||
1041          (I->Support() != iCurrE2)) {
1042         //      RemInterf = Standard_False;//debug ...
1043         continue;
1044       }
1045       gk = I->GeometryType();
1046       gi = I->Geometry();
1047       if(gk == kind1) {
1048         if(gi == ipv1) {
1049           DS.RemoveShapeInterference(DSEdge, I);
1050           if(!DS.HasGeometry(DSEdge)) {
1051             //      if(RemInterf || (!lioloi.More())) {
1052             RemoveEdgeSameDomain(iCurrE1, iCurrE2); // NYI : SameDomain
1053             DS.ChangeKeepShape(iCurrE1, FindKeep);
1054             //    } 
1055           } 
1056         }
1057       }
1058       else if(gk == kind2) {
1059         if(gi == ipv2) {
1060           DS.RemoveShapeInterference(DSEdge, I);
1061           if(!DS.HasGeometry(DSEdge)) {
1062             //      if(RemInterf || (!lioloi.More())) {//debug
1063             RemoveEdgeSameDomain(iCurrE1, iCurrE2); // NYI : SameDomain
1064             DS.ChangeKeepShape(iCurrE1, FindKeep);
1065             //    } 
1066           }
1067         }
1068       }
1069     }
1070   }
1071 }
1072
1073 //=======================================================================
1074 //function : RemoveEdgeInterferences
1075 //purpose  : case of SectEdge coming from Curve
1076 //           for each of faces F1 and F2, explode into Edges
1077 //           for each Edge :
1078 //           remove the interferences that have a vertex of SectEdge
1079 //           as a geometry. If no other interferences are attached to  
1080 //           these Edges, and if the Edges are not SameDomain,
1081 //           make unKeepShape.
1082 //=======================================================================
1083
1084 void BRepAlgo_DSAccess::RemoveEdgeInterferences
1085 (const Standard_Integer iF1,
1086  const Standard_Integer iF2,
1087  const Standard_Integer iCurve)
1088 {
1089   TopOpeBRepDS_Kind gk1, gk2;
1090   Standard_Integer gi1, gi2;
1091   
1092   PntVtxOnCurve(iCurve, gi1, gk1, gi2, gk2);
1093
1094   if (!mySetOfKeepPoint.IsEmpty()) {
1095     if (mySetOfKeepPoint.Contains(gi1)) gi1 = 0;
1096     if (mySetOfKeepPoint.Contains(gi2)) gi2 = 0;   
1097   }
1098   
1099   if (gi1 || gi2)
1100     RemoveEdgeInterferencesFromFace(iF1, iF2, gi1, gk1, gi2, gk2);
1101 }
1102
1103 //=======================================================================
1104 //function : RemoveFaceInterferences
1105 //purpose  : case of SectEdge coming from Edge(s)
1106 //        Remove interferences between F1 and F2 concerning 
1107 //        DSEdge (= E1 or E2) :
1108 //              a) if DSEdge is not SameDomain -> the edge is Removed
1109 //              b) if among other interferences of DSEdge of 
1110 //                 GeomtryType == VERTEX, there is none 
1111 //                 with Edge of DSFace(= F1 or F2)
1112 //        if DSFace has no more interferences and is not SameDomain,
1113 //        make unkeep DSFace.
1114 //=======================================================================
1115
1116 void BRepAlgo_DSAccess::RemoveFaceInterferences
1117 (const Standard_Integer iF1,
1118  const Standard_Integer iF2,
1119  const Standard_Integer iE1,
1120  const Standard_Integer iE2)
1121 {
1122   if(!iF1 || !iF2)
1123     return;
1124   TopOpeBRepDS_DataStructure& DS = myHDS->ChangeDS();
1125   TopOpeBRepDS_ListIteratorOfListOfInterference lioloi;//, lioloei, liolofi;
1126   TopTools_ListIteratorOfListOfShape liolos;
1127   TopOpeBRepDS_Kind gk;
1128   TopExp_Explorer exp;
1129   Standard_Integer i, iCurrF1, iCurrF2, j, iCurrE1, /*iCurrE2,*/ gi; // skl
1130   Standard_Boolean RemInterf;
1131   
1132   for(i = 1; i <= 2; i++) {
1133     iCurrF1 = ((i == 1) ? iF1 : iF2);
1134     iCurrF2 = ((i == 1) ? iF2 : iF1);
1135     const TopoDS_Shape& DSFace = DS.Shape(iCurrF1);
1136     if(DSFace.IsNull())
1137       continue;
1138     const TopOpeBRepDS_ListOfInterference& loi = DS.ShapeInterferences(DSFace);
1139     for(lioloi.Initialize(loi); lioloi.More(); lioloi.Next()) {
1140       Handle(TopOpeBRepDS_Interference) I = lioloi.Value();
1141       if (I.IsNull()) continue;
1142       if((I->SupportType() != TopOpeBRepDS_FACE) ||
1143          (I->Support() != iCurrF2)) {
1144         continue;
1145       }
1146       gk = I->GeometryType();
1147       gi = I->Geometry();
1148       if(gk != TopOpeBRepDS_EDGE) continue;
1149       for(j = 1; j <= 2; j++) {
1150         iCurrE1 = ((j == 1) ? iE1 : iE2);
1151         //iCurrE2 = ((j == 1) ? iE2 : iE1); // skl
1152         if(gi != iCurrE1) continue;
1153         // a) if DSEdge is not SameDomain -> the interference is Removed
1154         //    et DSEdge
1155         const TopoDS_Shape& DSEdge = DS.Shape(iCurrE1, FindKeep);
1156         if(DSEdge.IsNull())
1157           continue;
1158         if(!myHDS->HasSameDomain(DSEdge)) {
1159           if(!DS.HasGeometry(DSEdge)) {
1160             DS.RemoveShapeInterference(DSFace, I);
1161             DS.ChangeKeepShape(DSEdge, FindKeep);
1162           } else {
1163             // NYI : manage the case when the geometry of DSEdge 
1164             // NYI : is not connected anyhow with two faces
1165           }
1166           if(!DS.HasGeometry(DSFace)) {
1167             DS.ChangeKeepShape(DSFace, FindKeep);
1168           }
1169           continue;
1170         }
1171         // b) if no Edges of  SameDomain(DSEdge),
1172         //    belong to DSFace(= F1 or F2)
1173         //     -> the interference is removed
1174         const TopoDS_Shape& Edge = DS.Shape(iCurrE1, FindKeep);
1175         if(Edge.IsNull())
1176           continue;
1177         const TopTools_ListOfShape& loe = DS.ShapeSameDomain(Edge);
1178         RemInterf = Standard_True;
1179         for(liolos.Initialize(loe); liolos.More(); liolos.Next()) {
1180           const TopoDS_Shape& ESD = liolos.Value();
1181           for(exp.Init(DSFace, TopAbs_EDGE); exp.More(); exp.Next()) {
1182             if(ESD.IsSame(exp.Current())) {
1183               RemInterf = Standard_False;
1184               break;
1185             }
1186           }
1187           if(!RemInterf) break;
1188         }
1189         if(RemInterf) {
1190           //      RemoveSameDomain(iCurrF1, iCurrF2);
1191           
1192           if(!DS.HasGeometry(DSFace)) {
1193             if(!myHDS->HasSameDomain(DSFace))
1194               DS.ChangeKeepShape(DSFace, FindKeep);
1195           }
1196         }
1197         if(!DS.HasGeometry(DSFace) && !myHDS->HasSameDomain(DSFace))
1198           DS.ChangeKeepShape(DSFace, FindKeep);
1199       }
1200     }
1201   }
1202 }
1203
1204 //=======================================================================
1205 //function : RemoveFaceInterferences
1206 //purpose  : case of SectEdge from Curve
1207 //           remove interferences of Geometry iCurve between F1 and F2.
1208 //           if Face(= F1 or F2) has noother interference, and if Face
1209 //           is not SameDomain, make unKeepShape Face.
1210 //=======================================================================
1211
1212 void BRepAlgo_DSAccess::RemoveFaceInterferences
1213 (const Standard_Integer iF1,
1214  const Standard_Integer iF2,
1215  const Standard_Integer iCurve)
1216 {
1217   TopOpeBRepDS_DataStructure& DS = myHDS->ChangeDS();
1218   TopOpeBRepDS_ListIteratorOfListOfInterference lioloi;
1219   TopOpeBRepDS_Kind gk;
1220   Standard_Integer i, iCurrF1, iCurrF2, gi;
1221
1222   for(i = 1; i <= 2; i++) {
1223     iCurrF1 = ((i == 1) ? iF1 : iF2);
1224     iCurrF2 = ((i == 1) ? iF2 : iF1);
1225     const TopoDS_Shape& DSFace = DS.Shape(iCurrF1);
1226     const TopOpeBRepDS_ListOfInterference& loi = DS.ShapeInterferences(DSFace);
1227     for(lioloi.Initialize(loi); lioloi.More(); lioloi.Next()) {
1228       Handle(TopOpeBRepDS_Interference) I = lioloi.Value();
1229       if (I.IsNull()) continue;
1230       if((I->SupportType() != TopOpeBRepDS_FACE) ||
1231          (I->Support() != iCurrF2)) {
1232         break;;
1233       }
1234     }
1235     for(lioloi.Initialize(loi); lioloi.More(); lioloi.Next()) {
1236       Handle(TopOpeBRepDS_Interference) I = lioloi.Value();
1237       if (I.IsNull()) continue;
1238       if((I->SupportType() != TopOpeBRepDS_FACE) ||
1239          (I->Support() != iCurrF2)) {
1240         continue;
1241       }
1242       gk = I->GeometryType();
1243       gi = I->Geometry();
1244       if(gk != TopOpeBRepDS_CURVE) continue;
1245       if(gi != iCurve) continue;
1246       DS.RemoveShapeInterference(DSFace, I);
1247 //      const TopoDS_Shape& interferenceface = DS.Shape(iCurrF2);
1248 //      DS.RemoveShapeInterference(interferenceface, I);
1249       if(!DS.HasGeometry(DSFace)) {
1250         const TopTools_ListOfShape& los = DS.ShapeSameDomain(DSFace);
1251         if(los.IsEmpty())
1252           DS.ChangeKeepShape(DSFace, FindKeep);
1253       }
1254 //      if(!DS.HasGeometry(interferenceface)) {
1255 //      const TopTools_ListOfShape& los = DS.ShapeSameDomain(interferenceface);
1256 //      if(los.IsEmpty())
1257 //        DS.ChangeKeepShape(interferenceface, FindKeep);
1258 //      }
1259     }
1260   }
1261 }
1262
1263 //=======================================================================
1264 //function : RemoveEdgeInterferencesFromFace
1265 //purpose  : Remove interferences of Edges from iF1 or iF2
1266 //           that have GeometryType kind1/kind2 and 
1267 //           Geometry ipv1/ipv2.
1268 //           if kind1/kind2 == TopAbs_VERTEX -> RemoveEdgeFromFace
1269 //=======================================================================
1270
1271 void BRepAlgo_DSAccess::RemoveEdgeInterferencesFromFace
1272 (const Standard_Integer iF1,
1273  const Standard_Integer iF2,
1274  const Standard_Integer ipv1,
1275  const TopOpeBRepDS_Kind kind1,
1276  const Standard_Integer ipv2,
1277  const TopOpeBRepDS_Kind kind2)
1278 {
1279   TopOpeBRepDS_DataStructure& DS = myHDS->ChangeDS();
1280   TopOpeBRepDS_ListIteratorOfListOfInterference lioloi;
1281   TopExp_Explorer exp, exp2;
1282   TopOpeBRepDS_Kind sk, gk;
1283   Standard_Integer i, iCurrF1, iCurrF2, iE = 0, si, gi;
1284
1285   for(i = 1; i <= 2; i++) {
1286     iCurrF1 = ((i == 1) ? iF1 : iF2);
1287     iCurrF2 = ((i == 1) ? iF2 : iF1);
1288     const TopoDS_Shape& DSFace = DS.Shape(iCurrF1, FindKeep);
1289     if(DSFace.IsNull())
1290       continue;
1291     exp.Init(DSFace, TopAbs_EDGE);
1292     for(; exp.More(); exp.Next()) {
1293       const TopoDS_Shape& DSEdge = exp.Current();
1294       iE = DS.Shape(DSEdge, FindKeep);
1295       if(!iE) continue;
1296       const TopOpeBRepDS_ListOfInterference& loi =
1297         DS.ShapeInterferences(DSEdge);
1298       for(lioloi.Initialize(loi); lioloi.More(); lioloi.Next()) {
1299         Handle(TopOpeBRepDS_Interference) I = lioloi.Value();
1300         if (I.IsNull()) continue;
1301         sk = I->SupportType();
1302         si = I->Support();
1303         if((sk != TopOpeBRepDS_FACE) || (si != iCurrF2)) {
1304           if(sk != TopOpeBRepDS_EDGE)
1305             continue;
1306           const TopoDS_Shape& DSFace2 = DS.Shape(iCurrF2, FindKeep);
1307           exp2.Init(DSFace2, TopAbs_EDGE);
1308           for(; exp2.More(); exp2.Next()) {
1309             if(si == DS.Shape(exp2.Current(), FindKeep))
1310               break;
1311           }
1312           if(!exp2.More())
1313             continue;
1314         }
1315         gk = I->GeometryType();
1316         gi = I->Geometry();
1317         if(gk == kind1) {
1318           if(gi == ipv1) {
1319             DS.RemoveShapeInterference(DSEdge, I);
1320 //          if(!DS.HasGeometry(DSEdge)) {
1321 //            const TopTools_ListOfShape& los = DS.ShapeSameDomain(DSEdge);
1322 //            if(los.IsEmpty()) {
1323 //              DS.ChangeKeepShape(iE, FindKeep);
1324 //            }
1325 //          }
1326           }
1327           else if(gk == kind2) {
1328             if(gi == ipv2) {
1329               DS.RemoveShapeInterference(DSEdge, I);
1330 //            if(!DS.HasGeometry(DSEdge)) {
1331 //              const TopTools_ListOfShape& los = DS.ShapeSameDomain(DSEdge);
1332 //              if(los.IsEmpty()) {
1333 //                DS.ChangeKeepShape(iE, FindKeep);
1334 //              }
1335 //            }
1336             }
1337           }
1338           else continue;
1339         }
1340       }
1341     }
1342     if(kind1 == TopOpeBRepDS_VERTEX)
1343       RemoveEdgeFromFace(iCurrF1,ipv1);
1344     if(kind2 == TopOpeBRepDS_VERTEX)
1345       RemoveEdgeFromFace(iCurrF1,ipv2);
1346   }
1347 }
1348
1349 //=======================================================================
1350 //function : RemoveEdgeFromFace
1351 //purpose  : Remove from DS the Edges, which belong to iF
1352 //           and have iV as vertex if they do not have Geometry and
1353 //           are not SameDomain.
1354 //=======================================================================
1355
1356 void BRepAlgo_DSAccess::RemoveEdgeFromFace
1357 (const Standard_Integer iF,
1358  const Standard_Integer iV)
1359 {
1360   if(!iF || !iV)
1361     return;
1362   TopOpeBRepDS_DataStructure& DS = myHDS->ChangeDS();
1363   const TopoDS_Shape& DSFace = DS.Shape(iF, FindKeep);
1364   const TopoDS_Shape& Vertex = DS.Shape(iV, FindKeep);
1365   if(DSFace.IsNull() || Vertex.IsNull())
1366     return;
1367   TopExp_Explorer exp(DSFace, TopAbs_EDGE), exp2;
1368   for(; exp.More(); exp.Next()) {
1369     const TopoDS_Shape& Edge = exp.Current();
1370 #ifdef DEB
1371 //    Standard_Integer iEdge2 = DS.Shape(Edge, FindKeep);
1372 //    Standard_Integer iEdge3 = DS.Shape(Edge);
1373 #endif
1374                               
1375     if(!DS.HasShape(Edge)) 
1376       continue;
1377     exp2.Init(Edge, TopAbs_VERTEX);
1378     for(; exp2.More(); exp2.Next()) {
1379 #ifdef DEB
1380 //      Standard_Integer iEdge5 = DS.Shape(Vertex, FindKeep);
1381 //      Standard_Integer iEdge4 = DS.Shape(Vertex);
1382 //      Standard_Integer iEdge6 = DS.Shape(exp2.Current(), FindKeep);
1383 //      Standard_Integer iEdge7 = DS.Shape(exp2.Current());
1384 #endif
1385                                 
1386       if(Vertex.IsSame(exp2.Current())) {
1387         if(!DS.HasGeometry(Edge)) {
1388           const TopTools_ListOfShape& los = DS.ShapeSameDomain(Edge);
1389           if(los.IsEmpty()) {
1390 #ifdef DEB
1391 //          Standard_Integer iEdge = DS.Shape(Edge);
1392 #endif
1393             DS.ChangeKeepShape(Edge, FindKeep);
1394           }
1395         }
1396       }
1397     }
1398   }
1399 }
1400
1401 //=======================================================================
1402 //function : PntVtxOnCurve
1403 //purpose  : To find the points/vertices on curves
1404 //=======================================================================
1405
1406 void BRepAlgo_DSAccess::PntVtxOnCurve
1407 (const Standard_Integer iCurve,
1408  Standard_Integer& ipv1,
1409  TopOpeBRepDS_Kind& pvk1,
1410  Standard_Integer& ipv2,
1411  TopOpeBRepDS_Kind& pvk2)
1412 {
1413   TopOpeBRepDS_DataStructure& DS = myHDS->ChangeDS();
1414   
1415   const TopOpeBRepDS_Curve& C = DS.Curve(iCurve);
1416   TopOpeBRepDS_Kind pvk; 
1417   Standard_Integer ipv, iMother = C.Mother(), igoodC = iCurve, comp = 0;
1418   if(iMother) igoodC = iMother;
1419 //#ifndef DEB
1420   TopOpeBRepDS_PointIterator PII = myHDS->CurvePoints(igoodC);
1421   TopOpeBRepDS_PointIterator& PIt = PII; // skl : I change "M_PI" to "PIt"
1422 //#else
1423 //  TopOpeBRepDS_PointIterator& PIt = myHDS->CurvePoints(igoodC);
1424 //#endif
1425   for(;PIt.More(); PIt.Next()) {
1426     comp++;
1427     if(comp > 2)
1428       // Standard_Error ...
1429       return;
1430     ipv = PIt.Current();
1431     // a point or a vertex is removed from the DS
1432     if(PIt.IsPoint()) {
1433       pvk = TopOpeBRepDS_POINT;
1434       DS.ChangeKeepPoint(ipv, FindKeep);
1435     }
1436     else if(PIt.IsVertex()) {
1437       pvk = TopOpeBRepDS_VERTEX;
1438       DS.ChangeKeepShape(ipv, FindKeep);
1439     }
1440     else continue;
1441     ((comp == 1) ? ipv1 : ipv2) = ipv;
1442     ((comp == 1) ? pvk1 : pvk2) = pvk;
1443   }
1444 }
1445
1446 //=======================================================================
1447 //function : PntVtxOnSectEdge
1448 //purpose  : Points/Vertexes  on  SectEdge are found
1449 //=======================================================================
1450
1451 void BRepAlgo_DSAccess::PntVtxOnSectEdge
1452 (const TopoDS_Shape& SectEdge,
1453  Standard_Integer& ipv1,
1454  TopOpeBRepDS_Kind& pvk1,
1455  Standard_Integer& ipv2,
1456  TopOpeBRepDS_Kind& pvk2)
1457 {
1458 //  myHB->ChangeBuilder();
1459   TopOpeBRepDS_DataStructure& DS = myHDS->ChangeDS();
1460   TopOpeBRepDS_Kind kind = TopOpeBRepDS_POINT;
1461   TopExp_Explorer exp(SectEdge, TopAbs_VERTEX);
1462   Standard_Integer i = 1, ipv;
1463   
1464   for(; exp.More(); exp.Next(), i++) {    
1465     const TopoDS_Shape& DSVertex = exp.Current();
1466     ipv = myHB->GetDSPointFromNewVertex(DSVertex);
1467     if(!ipv) {
1468       ipv = DS.Shape(DSVertex, FindKeep);
1469       kind = TopOpeBRepDS_VERTEX;
1470       if(!ipv)
1471         // Standard_Error ...
1472         return;
1473     }
1474     
1475     if(i == 1) {
1476       ipv1 = ipv;
1477       pvk1 = kind;
1478     }    
1479     else if(i == 2) {
1480       ipv2 = ipv;
1481       pvk2 = kind;
1482     }
1483     else
1484       // Standard_Error ...
1485       return;
1486   }
1487 }
1488
1489 //=======================================================================
1490 //function : RemoveEdgeSameDomain
1491 //purpose  : 
1492 //=======================================================================
1493
1494 void BRepAlgo_DSAccess::RemoveEdgeSameDomain
1495 (const Standard_Integer /*iE1*/,
1496  const Standard_Integer /*iE2*/)
1497 {
1498   return;
1499 /*  TopOpeBRepDS_DataStructure& DS = myHDS->ChangeDS();
1500   const TopoDS_Shape& E1 = DS.Shape(iE1);
1501   const TopoDS_Shape& E2 = DS.Shape(iE2);
1502   TopAbs_ShapeEnum ts1, ts2;
1503   ts1 = E1.ShapeType();
1504   ts2 = E2.ShapeType();
1505   if((ts1 != TopAbs_EDGE) ||
1506      (ts2 != TopAbs_EDGE)) 
1507     return;
1508   TopTools_ListOfShape& lossd = DS.ChangeShapeSameDomain(E1);
1509   if(lossd.IsEmpty())
1510     return;
1511   Standard_Integer exte = lossd.Extent();
1512   if(exte == 1) {
1513     if(lossd.First().IsSame(E2))
1514       DS.UnfillShapesSameDomain(E1,E2);
1515     return;
1516   }*/
1517 }
1518
1519 //=======================================================================
1520 //function : RemoveFaceSameDomain
1521 //purpose  : remove SameDomain information of glued faces 
1522 //=======================================================================
1523
1524 void BRepAlgo_DSAccess::RemoveFaceSameDomain
1525 (const TopoDS_Shape& C)
1526 {
1527 //  myHB->ChangeBuilder();
1528   TopOpeBRepDS_DataStructure& DS = myHDS->ChangeDS();
1529
1530 //TColStd_ListIteratorOfListOfInteger it;
1531   TopExp_Explorer exp(C, TopAbs_EDGE);
1532   Standard_Integer  iE1, iE2, iE, /*NbF,*/ iF1, iF2, iCurrF1, iCurrF2,   iC =0; // skl
1533   iF1 = iF2 = iCurrF1 = iCurrF2 = 0;
1534   Standard_Boolean b;
1535   const TopoDS_Shape& SectEdge = exp.Current();
1536   
1537   for(; exp.More(); exp.Next()) {
1538     iC = myHB->GetDSCurveFromSectEdge(SectEdge);
1539     if(!iC && !SectEdge.IsNull())
1540       break;
1541 //  const TopoDS_Shape& SectEdge = exp.Current();
1542   }
1543   if(!iC && !SectEdge.IsNull()) {
1544     iE1 = myHB->GetDSEdgeFromSectEdge(SectEdge, 1);
1545     iE2 = myHB->GetDSEdgeFromSectEdge(SectEdge, 2);
1546     if(iE1 && iE2) return;
1547     iE = (iE1 ? iE1 : iE2);
1548     if(!iE) return;
1549     
1550     TColStd_ListOfInteger& loi = FindGoodFace(iE, iF1, b);
1551     if(!b) return;
1552     if(exp.More())
1553       exp.Next();
1554     //NbF = loi.Extent(); // skl
1555     for(; exp.More(); exp.Next()) {
1556       // skl : I change "SectEdge" to "SectEdg"
1557       const TopoDS_Shape& SectEdg = exp.Current();
1558       iC = myHB->GetDSCurveFromSectEdge(SectEdg);
1559       if(!iC) {
1560         iE1 = myHB->GetDSEdgeFromSectEdge(SectEdg, 1);
1561         iE2 = myHB->GetDSEdgeFromSectEdge(SectEdg, 2);
1562         if(iE1 && iE2) return;
1563         iE = (iE1 ? iE1 : iE2);
1564         if(!iE) return;
1565         
1566         TColStd_ListOfInteger& loi2 = FindGoodFace(iE, iCurrF1, b);
1567         if(!b) return;
1568         if(!iCurrF1 || !iF1) return;
1569         if(iCurrF1 != iF1) {
1570           if(loi2.Extent() == 1) iCurrF2 = loi2.First();
1571           if(iCurrF2 == iF1) continue;
1572           if(loi.Extent() == 1) iF2 = loi.First();
1573
1574           if(!iCurrF2 || !iF2) return;
1575           if((iCurrF1 == iF2) ||
1576              (iCurrF2 == iF2)) {
1577             iF1 = iF2;
1578             continue;
1579           }
1580           return;
1581         } 
1582       }
1583     }
1584     
1585     const TopoDS_Shape& FSD = DS.Shape(iF1);
1586     if(FSD.IsNull()) 
1587       return;
1588     TopTools_ListOfShape& ssd = DS.ChangeShapeSameDomain(FSD);
1589     TopTools_ListIteratorOfListOfShape itssd(ssd);
1590     TopExp_Explorer exp2;
1591     for(; itssd.More(); itssd.Next()) {
1592       exp2.Init(itssd.Value(), TopAbs_VERTEX);
1593       for(; exp2.More(); exp2.Next()) {
1594         const TopoDS_Shape& exp2Curr = exp2.Current();
1595         exp.Init(C, TopAbs_VERTEX);
1596         for(; exp.More(); exp.Next()) {
1597           if(exp2Curr.IsSame(exp.Current()))
1598             break;
1599         }
1600         if(exp.More())
1601           break;
1602       }
1603       if(exp2.More())
1604         break;
1605     }
1606     
1607     if(exp2.More()) {
1608       const TopoDS_Shape& FSD2 = itssd.Value();
1609       Standard_Integer iFSD = DS.Shape(FSD), iFSD2 = DS.Shape(FSD2);
1610       RemoveFaceSameDomain(iFSD, iFSD2);      
1611 //      DS.UnfillShapesSameDomain(FSD, FSD2);
1612     }
1613   }
1614 }
1615
1616 //=======================================================================
1617 //function : FindGoodFace
1618 //purpose  : 
1619 //=======================================================================
1620
1621 TColStd_ListOfInteger& BRepAlgo_DSAccess::FindGoodFace
1622 (const Standard_Integer iE,
1623  Standard_Integer& iF1,
1624  Standard_Boolean& b)
1625 {
1626 //  myHB->ChangeBuilder();
1627   b = Standard_False;
1628   TColStd_ListOfInteger& loi = myHB->GetDSFaceFromDSEdge(iE, 1);
1629   if(loi.Extent() == 1) {
1630     iF1 = loi.First();
1631     b = Standard_True;
1632     TColStd_ListOfInteger& loi2 = myHB->GetDSFaceFromDSEdge(iE, 2);
1633     return loi2;
1634   }
1635   else {
1636     TColStd_ListOfInteger& loi2 = myHB->GetDSFaceFromDSEdge(iE, 2);
1637     if(loi2.Extent() == 1) {
1638       b = Standard_True;
1639       iF1 = loi2.First();
1640       return loi;
1641     }
1642   }
1643   b = Standard_False;
1644   return myEmptyListOfInteger;
1645 }
1646
1647 //=======================================================================
1648 //function : RemoveFaceSameDomain
1649 //purpose  : 
1650 //=======================================================================
1651
1652 void BRepAlgo_DSAccess::RemoveFaceSameDomain
1653 (const Standard_Integer iF1,
1654  const Standard_Integer iF2)
1655 {
1656   TopOpeBRepDS_DataStructure& DS = myHDS->ChangeDS();
1657   const TopoDS_Shape& F1 = DS.Shape(iF1, FindKeep);
1658   const TopoDS_Shape& F2 = DS.Shape(iF2, FindKeep);
1659   if(F1.IsNull() || F2.IsNull())
1660     return;
1661
1662
1663   Standard_Integer iref1 = DS.SameDomainRef(F1),
1664   iref2 = DS.SameDomainRef(F2), istart, iend;
1665   if(iref1 == iF1)
1666     DS.SameDomainRef(F2,iF2);
1667   if(iref2 == iF1)
1668     DS.SameDomainRef(F1,iF1);
1669   DS.UnfillShapesSameDomain(F1,F2);
1670
1671   if(iref1 != iref2)
1672     return;
1673   Standard_Boolean iF1iF2IsConnected = Standard_False;
1674   TColStd_IndexedMapOfInteger moi;
1675   moi.Clear();
1676   if(iref2 == iF2) {
1677     istart = iF2;
1678     iend = iF1;
1679   }
1680   else {
1681     istart = iF1;
1682     iend = iF2;
1683   }
1684   moi.Add(istart);
1685   Standard_Integer NbConnect = 0, icurr;
1686   while(moi.Extent() > NbConnect) {
1687     NbConnect++;
1688     icurr = moi.FindKey(NbConnect);
1689     DS.SameDomainRef(icurr, istart);
1690     const TopTools_ListOfShape& los = DS.ShapeSameDomain(icurr);
1691     if(los.IsEmpty()) {
1692       const TopoDS_Shape& SNSD = DS.Shape(icurr);
1693       DS.SameDomainRef(SNSD, 0);
1694     }
1695     TopTools_ListIteratorOfListOfShape li(los);
1696     for(; li.More(); li.Next()) {
1697       Standard_Integer iCurrShap = DS.Shape(li.Value(), FindKeep);
1698       if(!iCurrShap)
1699         return;
1700       if(iCurrShap == iend)
1701         iF1iF2IsConnected = Standard_True;
1702       moi.Add(iCurrShap);
1703     }
1704   }
1705   if(!iF1iF2IsConnected) {
1706     moi.Clear();
1707     moi.Add(iend);
1708     NbConnect = 0;
1709     while(moi.Extent() > NbConnect) {
1710       NbConnect++;
1711       icurr = moi.FindKey(NbConnect);
1712       DS.SameDomainRef(icurr, iend);
1713       const TopTools_ListOfShape& los = DS.ShapeSameDomain(icurr);
1714       if(los.IsEmpty()) {
1715         const TopoDS_Shape& SNSD = DS.Shape(icurr);
1716         DS.SameDomainRef(SNSD, 0);
1717       }
1718       TopTools_ListIteratorOfListOfShape li(los);
1719       for(; li.More(); li.Next()) {
1720         Standard_Integer iCurrShap = DS.Shape(li.Value(), FindKeep);
1721         if(!iCurrShap)
1722           return;
1723         moi.Add(iCurrShap);
1724       }
1725     }
1726   }
1727 }
1728
1729 //=======================================================================
1730 //function : DS
1731 //purpose  : 
1732 //=======================================================================
1733
1734 const Handle(TopOpeBRepDS_HDataStructure)&
1735 BRepAlgo_DSAccess::DS() const
1736 {
1737   return myHDS;
1738 }
1739
1740 //=======================================================================
1741 //function : changeDS
1742 //purpose  : 
1743 //=======================================================================
1744 Handle(TopOpeBRepDS_HDataStructure)&
1745 BRepAlgo_DSAccess::ChangeDS()
1746 {
1747   return myHDS;
1748 }
1749
1750 //=======================================================================
1751 //function : Builder
1752 //purpose  : 
1753 //=======================================================================
1754
1755 const Handle(TopOpeBRepBuild_HBuilder)& 
1756 BRepAlgo_DSAccess::Builder() const
1757 {
1758   return myHB;
1759 }
1760
1761 //=======================================================================
1762 //function : ChangeBuilder
1763 //purpose  : 
1764 //=======================================================================
1765
1766 Handle(TopOpeBRepBuild_HBuilder)& 
1767 BRepAlgo_DSAccess::ChangeBuilder()
1768 {
1769   return myHB;
1770 }