0023024: Update headers of OCCT files
[occt.git] / src / BOP / BOP_SDFWESFiller.cxx
1 // Created on: 2001-06-06
2 // Created by: Peter KURNEV
3 // Copyright (c) 2001-2012 OPEN CASCADE SAS
4 //
5 // The content of this file is subject to the Open CASCADE Technology Public
6 // License Version 6.5 (the "License"). You may not use the content of this file
7 // except in compliance with the License. Please obtain a copy of the License
8 // at http://www.opencascade.org and read it completely before using this file.
9 //
10 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
11 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
12 //
13 // The Original Code and all software distributed under the License is
14 // distributed on an "AS IS" basis, without warranty of any kind, and the
15 // Initial Developer hereby disclaims all such warranties, including without
16 // limitation, any warranties of merchantability, fitness for a particular
17 // purpose or non-infringement. Please see the License for the specific terms
18 // and conditions governing the rights and limitations under the License.
19
20
21 #include <BOP_SDFWESFiller.ixx>
22
23 #include <gp_Pnt.hxx>
24
25 #include <TopoDS.hxx>
26 #include <TopoDS_Face.hxx>
27 #include <TopoDS_Shape.hxx>
28 #include <TopoDS_Edge.hxx>
29
30 #include <TopExp_Explorer.hxx>
31 #include <TopTools_IndexedMapOfOrientedShape.hxx>
32 #include <TopTools_IndexedMapOfShape.hxx>
33 #include <TopAbs_Orientation.hxx>
34
35 #include <BRep_Tool.hxx>
36
37 #include <TColStd_ListOfInteger.hxx>
38 #include <TColStd_IndexedMapOfInteger.hxx>
39 #include <TColStd_ListIteratorOfListOfInteger.hxx>
40
41 #include <BooleanOperations_ShapesDataStructure.hxx>
42 #include <BooleanOperations_StateOfShape.hxx>
43
44 #include <IntTools_Tools.hxx>
45 #include <IntTools_Context.hxx>
46
47 #include <BOPTools_Tools2D.hxx>
48 #include <BOPTools_Tools3D.hxx>
49 #include <BOPTools_ListOfPaveBlock.hxx>
50 #include <BOPTools_ListIteratorOfListOfPaveBlock.hxx>
51 #include <BOPTools_PaveBlock.hxx>
52 #include <BOPTools_PaveFiller.hxx>
53 #include <BOPTools_SplitShapesPool.hxx>
54 #include <BOPTools_CommonBlockPool.hxx>
55 #include <BOPTools_ListOfCommonBlock.hxx>
56 #include <BOPTools_ListIteratorOfListOfCommonBlock.hxx>
57 #include <BOPTools_CommonBlock.hxx>
58 #include <BOPTools_Tools.hxx>
59 #include <BOPTools_PointBetween.hxx>
60 #include <BOPTools_SolidStateFiller.hxx>
61
62 #include <BOPTColStd_Dump.hxx>
63 #include <TopTools_MapOfShape.hxx>
64 static Standard_Boolean IsValidSeam(const TopoDS_Edge& aE,
65                                     const TopoDS_Face& aF,
66                                     const Standard_Real aT,
67                                     const Handle(IntTools_Context)& aContext);
68
69 static void CorrespondantSeam(const TopoDS_Edge& aSpE1Seam11,
70                               const Standard_Real aT1,
71                               const TopoDS_Edge& aSpE1Seam21,
72                               const TopoDS_Edge& aSpE1Seam22,
73                               const Standard_Real aT2,
74                               const TopoDS_Face& aF1FWD,
75                               TopoDS_Edge& aSS);
76
77 static void TreatSDSeams (const TopoDS_Edge& aSpE1Seam11,
78                           const Standard_Real aT1,
79                           const TopoDS_Face& aF1FWD,
80                           const TopoDS_Edge& aSpE1Seam21,
81                           const Standard_Real aT2,
82                           const TopoDS_Face& aF2FWD,
83                           const Standard_Boolean bIsTakenSp1,
84                           BOP_WireEdgeSet& aWES,
85                           const Handle(IntTools_Context)& aContext);
86
87
88 //=======================================================================
89 // function: BOP_SDFWESFiller::BOP_SDFWESFiller
90 // purpose: 
91 //=======================================================================
92   BOP_SDFWESFiller::BOP_SDFWESFiller()
93 :
94   myDSFiller(NULL),
95   myOperation(BOP_UNKNOWN),
96   myNF1(0),
97   myNF2(0),
98   mySenseFlag(0)
99 {}
100
101 //=======================================================================
102 // function: BOP_SDFWESFiller::BOP_SDFWESFiller
103 // purpose: 
104 //=======================================================================
105   BOP_SDFWESFiller::BOP_SDFWESFiller(const Standard_Integer nF1,
106                                      const Standard_Integer nF2,
107                                      const BOPTools_DSFiller& aDSFiller)
108 :
109   myNF1(nF1),
110   myNF2(nF2),
111   mySenseFlag(0)
112 {
113   myDSFiller=(BOPTools_DSFiller*) &aDSFiller;
114   Prepare();
115 }
116 //=======================================================================
117 // function: SetStatesMap
118 // purpose: 
119 //=======================================================================
120   void BOP_SDFWESFiller::SetStatesMap (const BOPTools_IndexedDataMapOfIntegerState& aMap)
121 {
122   myStatesMap.Clear();
123   myStatesMap=aMap;
124 }
125 //=======================================================================
126 // function: StatesMap
127 // purpose: 
128 //=======================================================================
129   const BOPTools_IndexedDataMapOfIntegerState& BOP_SDFWESFiller::StatesMap ()const
130 {
131   return myStatesMap;
132 }
133
134 //=======================================================================
135 // function: SetFaces
136 // purpose: 
137 //=======================================================================
138   void BOP_SDFWESFiller::SetFaces (const Standard_Integer nF1,
139                                    const Standard_Integer nF2)
140 {
141    myNF1=nF1;
142    myNF2=nF2;
143 }
144 //=======================================================================
145 // function: SetSenseFlag
146 // purpose: 
147 //=======================================================================
148   void BOP_SDFWESFiller::SetSenseFlag (const Standard_Integer iFlag)
149                                  
150 {
151    mySenseFlag=iFlag;
152 }
153
154 //=======================================================================
155 // function: SenseFlag
156 // purpose: 
157 //=======================================================================
158   Standard_Integer BOP_SDFWESFiller::SenseFlag () const
159                                  
160 {
161    return mySenseFlag;
162 }
163
164 //=======================================================================
165 // function: Faces
166 // purpose: 
167 //=======================================================================
168   void BOP_SDFWESFiller::Faces (Standard_Integer& nF1,
169                                 Standard_Integer& nF2) const
170 {
171    nF1=myNF1;
172    nF2=myNF2;
173 }
174 //=======================================================================
175 // function: SetDSFiller
176 // purpose: 
177 //=======================================================================
178   void BOP_SDFWESFiller::SetDSFiller(const BOPTools_DSFiller& aDSFiller)
179 {
180    myDSFiller=(BOPTools_DSFiller*) &aDSFiller;
181 }
182
183 //=======================================================================
184 // function: DSFiller
185 // purpose: 
186 //=======================================================================
187   const BOPTools_DSFiller& BOP_SDFWESFiller::DSFiller()const
188 {
189   return *myDSFiller;
190 }
191
192 //=======================================================================
193 // function: SetOperation
194 // purpose: 
195 //=======================================================================
196   void BOP_SDFWESFiller::SetOperation(const BOP_Operation anOp)
197 {
198   myOperation=anOp;
199 }
200 //=======================================================================
201 // function: Operation
202 // purpose: 
203 //=======================================================================
204   BOP_Operation BOP_SDFWESFiller::Operation()const
205 {
206   return myOperation;
207 }
208 //xf
209 //=======================================================================
210 //function : RejectedOnParts
211 //purpose  : 
212 //=======================================================================
213   const TopTools_ListOfShape& BOP_SDFWESFiller::RejectedOnParts()const
214 {
215   return myRejectedOnParts;
216 }
217 //xt
218 //=======================================================================
219 // function: Prepare
220 // purpose: 
221 //======================================================================= 
222   void BOP_SDFWESFiller::Prepare()
223 {
224   if (!myNF1 || !myNF2) {
225     return;
226   }
227   //
228   // 1. Prepare States 2D for the Faces' entities  (myStatesMap)
229   AssignStates(myNF1, myNF2);
230   AssignStates(myNF2, myNF1);
231   //
232   AssignDEStates(myNF1, myNF2);
233   AssignDEStates(myNF2, myNF1);
234   //
235   //  
236   // 2.
237   PrepareOnParts();
238   //
239 }
240
241 //=======================================================================
242 // function: Do
243 // purpose: 
244 //======================================================================= 
245   void BOP_SDFWESFiller::Do(const BOP_WireEdgeSet& pWES)
246 {
247   
248   myWES=(BOP_WireEdgeSet*) &pWES;
249
250   if (!myNF1 || !myNF2) {
251     return;
252   }
253   
254   //
255   // WES
256   switch (myOperation) {
257     case BOP_COMMON: {
258       PrepareWESForZone (myNF1, myNF2);
259       break;
260     }
261     case BOP_CUT: {
262       PrepareWESForCut (myNF1, myNF2);
263       break;
264     }
265     case BOP_CUT21: {
266       PrepareWESForCut (myNF2, myNF1);
267       break;
268     }
269     default: {
270       return;
271     }
272   }
273 }
274
275 //=======================================================================
276 // function: AssignStates
277 // purpose: 
278 //======================================================================= 
279   void BOP_SDFWESFiller::AssignStates(const Standard_Integer nF1,
280                                       const Standard_Integer nF2) 
281 {
282   const BooleanOperations_ShapesDataStructure& aDS=myDSFiller->DS();
283   const BOPTools_PaveFiller& aPaveFiller=myDSFiller->PaveFiller();
284   BOPTools_PaveFiller* pPaveFiller=(BOPTools_PaveFiller*) &aPaveFiller;
285   const BOPTools_SplitShapesPool& aSplitShapesPool=aPaveFiller.SplitShapesPool();
286   //
287   Standard_Integer aBid=0, nSplit, nE, nW, nSp, anEdgeFlag, aWireFlag, aNbPB, iRankF1;
288   TColStd_ListOfInteger aList1IN2, aList1ON2;
289   TColStd_IndexedMapOfInteger aSpMapIN, aSpMapON;
290   TColStd_ListIteratorOfListOfInteger anIt;
291   //
292   iRankF1=aDS.Rank(nF1);
293   //
294   const TopoDS_Face& aF1=TopoDS::Face(aDS.Shape(nF1));
295   // 
296   //  Splits that are from nF2 and are IN2D for nF2
297   pPaveFiller->SplitsInFace (aBid, nF1, nF2, aList1IN2);
298   
299   anIt.Initialize(aList1IN2);
300   for (; anIt.More();  anIt.Next()) {
301     nSplit=anIt.Value();
302     aSpMapIN.Add(nSplit);
303   }
304   //
305   // that are from nF2 and are ON2D for nF2
306   pPaveFiller->SplitsOnFace (aBid, nF1, nF2, aList1ON2);
307   
308   anIt.Initialize(aList1ON2);
309   for (; anIt.More();  anIt.Next()) {
310     nSplit=anIt.Value();
311     aSpMapON.Add(nSplit);
312   }
313   //
314   // Treatment of the Face's entities
315   aWireFlag=1;
316   TopExp_Explorer anExpWire(aF1, TopAbs_WIRE);
317   for (; anExpWire.More(); anExpWire.Next()) {
318     const TopoDS_Shape& aWire=anExpWire.Current();
319     nW=aDS.ShapeIndex(aWire, iRankF1);
320     anEdgeFlag=1;
321
322     TopExp_Explorer anExpEdge (aWire, TopAbs_EDGE);
323     for (; anExpEdge.More(); anExpEdge.Next()) {
324       const TopoDS_Shape& anEdge=anExpEdge.Current();
325       nE=aDS.ShapeIndex(anEdge, iRankF1);
326       
327       const BOPTools_ListOfPaveBlock& aLPB=aSplitShapesPool(aDS.RefEdge(nE));
328
329       aNbPB=aLPB.Extent();
330       if (!aNbPB) {
331         // the whole edge is OUT
332         myStatesMap.Add(nE, BooleanOperations_OUT);
333         continue;
334       }
335
336       BOPTools_ListIteratorOfListOfPaveBlock aPBIt(aLPB);
337
338       for (;  aPBIt.More();  aPBIt.Next()) {
339         const BOPTools_PaveBlock& aPB=aPBIt.Value();
340         nSp=aPB.Edge();
341         
342         if (aSpMapIN.Contains(nSp)) {// IN
343           myStatesMap.Add(nSp, BooleanOperations_IN);
344           anEdgeFlag=0;
345         }
346         else if (aSpMapON.Contains(nSp)) {// ON
347           myStatesMap.Add(nSp, BooleanOperations_ON);
348           anEdgeFlag=0;
349         }
350         else {// if (nSp!=nE) {// OUT
351           myStatesMap.Add(nSp, BooleanOperations_OUT);
352         }
353       } 
354     } //  enf of for (; anExpEdge.More(); anExpEdge.Next()) 
355      
356     if (anEdgeFlag) {// all Wire is out
357       myStatesMap.Add(nW, BooleanOperations_OUT);
358     }
359     else {
360       aWireFlag=0;
361     }
362   } // enf of for (; anExpEdge.More(); anExpEdge.Next())
363   
364   if (aWireFlag) { // all Face is out of nF2
365     myStatesMap.Add(nF1, BooleanOperations_OUT);
366   }
367 }
368
369 //=======================================================================
370 // function: PrepareOnParts
371 // purpose: 
372 //=======================================================================
373   void BOP_SDFWESFiller::PrepareOnParts ()
374 {
375   const BooleanOperations_ShapesDataStructure& aDS=myDSFiller->DS();
376   const BOPTools_PaveFiller& aPaveFiller=myDSFiller->PaveFiller();
377   BOPTools_PaveFiller* pPaveFiller=(BOPTools_PaveFiller*) &aPaveFiller;
378   BOPTools_CommonBlockPool& aCBPool=pPaveFiller->ChangeCommonBlockPool();
379   //
380   Standard_Integer aBid=0, nE1, nE2, aNbSpON, nSp1, nSp2, iRankF1;
381   Standard_Real aT1, aT2, aT, aTs; /*, U, V;*/ 
382   Standard_Boolean aFlag;
383   TColStd_ListOfInteger aLs;
384   TColStd_IndexedMapOfInteger aMap;
385   TopExp_Explorer anExpF1, anExpF2;
386   //
387   iRankF1=aDS.Rank(myNF1);
388
389   gp_Pnt aPx1;
390   //
391   TopoDS_Face aF1FWD, aF2FWD;
392   PrepareFaces(myNF1, myNF2, aF1FWD, aF2FWD);
393   //
394   // Process 
395   anExpF1.Init(aF1FWD, TopAbs_EDGE);
396   for (; anExpF1.More(); anExpF1.Next()) {
397     const TopoDS_Edge& anE1=TopoDS::Edge(anExpF1.Current());
398     //
399     if (BRep_Tool::Degenerated(anE1)){
400       continue;
401     }
402     //
403     nE1=aDS.ShapeIndex(anE1, iRankF1);
404
405     aLs.Clear();
406     pPaveFiller->SplitsOnFace(nE1, myNF2, aLs);
407     
408     aNbSpON=aLs.Extent();
409     if (!aNbSpON) {
410       continue;
411     }
412
413     aMap.Clear();
414     TColStd_ListIteratorOfListOfInteger anItLs(aLs);
415     for (; anItLs.More(); anItLs.Next()) {
416       aBid=anItLs.Value();
417       aMap.Add(aBid);
418     }
419
420     BOPTools_ListOfCommonBlock& aLCB=aCBPool(aDS.RefEdge(nE1));
421     BOPTools_ListIteratorOfListOfCommonBlock anItCB(aLCB);
422     for (; anItCB.More(); anItCB.Next()) {
423       BOPTools_CommonBlock& aCB=anItCB.Value();
424       BOPTools_PaveBlock& aPB1=aCB.PaveBlock1(nE1);
425       nSp1=aPB1.Edge();
426       if (aMap.Contains(nSp1)) {
427         //
428         // aPB1
429         aPB1.Parameters(aT1, aT2);
430         aT=BOPTools_Tools2D::IntermediatePoint(aT1, aT2);
431         BOPTools_Tools::PointOnEdge(anE1, aT, aPx1);
432
433         BOPTools_PointBetween aPointBetween;
434         aPointBetween.SetParameter(aT);
435         aPointBetween.SetPnt(aPx1);
436         
437         aPB1.SetPointBetween(aPointBetween);
438         //
439         // aPB2
440         BOPTools_PaveBlock& aPB2=aCB.PaveBlock2(nE1);
441         nE2=aPB2.OriginalEdge();
442         nSp2=aPB2.Edge();
443         const TopoDS_Edge& anE2=TopoDS::Edge(aDS.GetShape(nE2));
444         //
445         const Handle(IntTools_Context)& aContext=pPaveFiller->Context();
446         aFlag=aContext->ProjectPointOnEdge(aPx1, anE2, aTs);
447         //
448         if (!aFlag) {
449           BOPTColStd_Dump::PrintMessage(" BOP_SDFWESFiller::PrepareOnParts() failed\n");
450           return;
451         }
452
453         aPointBetween.SetParameter(aTs);
454         aPointBetween.SetPnt(aPx1);
455         
456         aPB2.SetPointBetween(aPointBetween);
457         //
458         BOPTools_ListOfCommonBlock& aLCB2=aCBPool(aDS.RefEdge(nE2));
459         BOPTools_ListIteratorOfListOfCommonBlock anItCB2(aLCB2);
460         for (; anItCB2.More(); anItCB2.Next()){
461           BOPTools_CommonBlock& aCB2=anItCB2.Value();
462           BOPTools_PaveBlock& aPB21=aCB2.PaveBlock1(nE2);
463           BOPTools_PaveBlock& aPB22=aCB2.PaveBlock2(nE2);
464           
465           if ((aPB21.IsEqual(aPB1) && aPB22.IsEqual(aPB2)) 
466               ||
467               (aPB21.IsEqual(aPB2) && aPB22.IsEqual(aPB1))) {
468             
469             aPointBetween.SetPnt(aPx1);
470             
471             aPointBetween.SetParameter(aTs);
472             aPB21.SetPointBetween(aPointBetween);
473             
474             aPointBetween.SetParameter(aT);
475             aPB22.SetPointBetween(aPointBetween);
476             
477             break;
478           }
479         }
480         //
481       }
482     }
483   }
484 }
485
486 //=======================================================================
487 // function: PrepareWESForZone
488 // purpose: 
489 //=======================================================================
490   void BOP_SDFWESFiller::PrepareWESForZone (const Standard_Integer nF1, 
491                                             const Standard_Integer nF2)
492 {
493   const BooleanOperations_ShapesDataStructure& aDS=myDSFiller->DS();
494   const BOPTools_PaveFiller& aPaveFiller=myDSFiller->PaveFiller();
495   const BOPTools_SplitShapesPool& aSplitShapesPool=aPaveFiller.SplitShapesPool();
496   BOP_WireEdgeSet& aWES=*myWES;
497   //
498   Standard_Integer nE, nSp, iRankF1, iRankF2; 
499   
500   TopAbs_Orientation anOr;
501   BooleanOperations_StateOfShape aState;
502   TopTools_IndexedMapOfOrientedShape aMap;
503   //
504   iRankF1=aDS.Rank(nF1);
505   iRankF2=aDS.Rank(nF2);
506   // W E S 
507   TopoDS_Face aF1FWD, aF2FWD; 
508   PrepareFaces(nF1, nF2, aF1FWD, aF2FWD);
509
510   TopExp_Explorer anExp;
511   //
512   // aF1FWD
513   anExp.Init(aF1FWD, TopAbs_EDGE);
514   for (; anExp.More(); anExp.Next()) {
515     const TopoDS_Shape& anE=anExp.Current();
516     anOr=anE.Orientation();
517
518     nE=aDS.ShapeIndex(anE, iRankF1);
519
520     const BOPTools_ListOfPaveBlock& aLPB=aSplitShapesPool(aDS.RefEdge(nE));
521     BOPTools_ListIteratorOfListOfPaveBlock aPBIt(aLPB);
522     for (; aPBIt.More(); aPBIt.Next()) {
523       const BOPTools_PaveBlock& aPB=aPBIt.Value();
524       nSp=aPB.Edge();
525       //>>>
526       if (!myStatesMap.Contains(nSp)) {
527         continue;
528       }
529       //>>>
530       aState=myStatesMap.FindFromKey(nSp);
531       
532       if (aState==BooleanOperations_IN) {
533         
534         const TopoDS_Shape& aSplit=aDS.Shape(nSp);
535         TopoDS_Edge aSS=TopoDS::Edge(aSplit);
536         aSS.Orientation(anOr);
537         //
538         if (aMap.Contains(aSS)) {
539           continue;
540         }
541         //
542         aWES.AddStartElement (aSS);
543         aMap.Add(aSS);  
544
545         if (BRep_Tool::IsClosed(aSS, aF1FWD)){
546           TopoDS_Shape EE=aSS.Reversed();
547           aWES.AddStartElement (EE);
548           aMap.Add(EE);
549         }
550       }
551     }
552   }
553   //
554   // aF2FWD
555   aMap.Clear();
556   anExp.Init(aF2FWD, TopAbs_EDGE);
557   for (; anExp.More(); anExp.Next()) {
558     const TopoDS_Shape& anE=anExp.Current();
559
560     anOr=anE.Orientation();
561
562     nE=aDS.ShapeIndex(anE, iRankF2);
563
564     const BOPTools_ListOfPaveBlock& aLPB=aSplitShapesPool(aDS.RefEdge(nE));
565     
566     BOPTools_ListIteratorOfListOfPaveBlock aPBIt(aLPB);
567     for (; aPBIt.More(); aPBIt.Next()) {
568       const BOPTools_PaveBlock& aPB=aPBIt.Value();
569       nSp=aPB.Edge();
570       //>>>
571       if (!myStatesMap.Contains(nSp)) {
572         continue;
573       }
574       //>>>
575       aState=myStatesMap.FindFromKey(nSp);
576       
577       if (aState==BooleanOperations_IN) {
578         const TopoDS_Shape& aSplit=aDS.Shape(nSp);
579         TopoDS_Edge aSS=TopoDS::Edge(aSplit);
580         //
581         if (!BOPTools_Tools2D::HasCurveOnSurface(aSS, aF1FWD)) {
582           continue;
583         }
584         //
585         aSS.Orientation(anOr);
586         //
587         if (aMap.Contains(aSS)) {
588           continue;
589         }
590         //      
591         aWES.AddStartElement (aSS);
592         aMap.Add(aSS);
593
594         if (BRep_Tool::IsClosed(aSS, aF2FWD)){
595           TopoDS_Shape EE=aSS.Reversed();
596           aWES.AddStartElement (EE);
597           aMap.Add(EE);
598         }
599       }
600     }
601   }
602
603   PrepareOnParts(nF1, nF2, BOP_COMMON);
604 }
605
606 //=======================================================================
607 // function: PrepareWESForCut
608 // purpose: 
609 //=======================================================================
610   void BOP_SDFWESFiller::PrepareWESForCut (const Standard_Integer nF1, 
611                                            const Standard_Integer nF2)
612 {
613   const BooleanOperations_ShapesDataStructure& aDS=myDSFiller->DS();
614   const BOPTools_PaveFiller& aPaveFiller=myDSFiller->PaveFiller();
615   const BOPTools_SplitShapesPool& aSplitShapesPool=aPaveFiller.SplitShapesPool();
616   BOP_WireEdgeSet& aWES=*myWES;
617   //
618   Standard_Integer  nE, nSp, nPB, iRankF2;
619   TopAbs_Orientation anOr;
620   BooleanOperations_StateOfShape aState;
621
622   iRankF2=aDS.Rank(nF2);
623   //
624   // W E S 
625   TopoDS_Face aF1FWD, aF2FWD; 
626   PrepareFaces(nF1, nF2, aF1FWD, aF2FWD);
627
628   aF2FWD.Reverse();
629   
630   TopExp_Explorer anExp;
631   //
632   //  aF2FWD
633   anExp.Init(aF2FWD, TopAbs_EDGE);
634   for (; anExp.More(); anExp.Next()) {
635     const TopoDS_Shape& anE=anExp.Current();
636     anOr=anE.Orientation();
637
638     nE=aDS.ShapeIndex(anE, iRankF2);
639
640     const BOPTools_ListOfPaveBlock& aLPB=aSplitShapesPool(aDS.RefEdge(nE));
641
642     nPB=aLPB.Extent();
643     if (nPB) {
644       BOPTools_ListIteratorOfListOfPaveBlock aPBIt(aLPB);
645       for (; aPBIt.More(); aPBIt.Next()) {
646         const BOPTools_PaveBlock& aPB=aPBIt.Value();
647         nSp=aPB.Edge();
648         //>>>
649         if (!myStatesMap.Contains(nSp)) {
650           continue;
651         }
652         //>>>
653         aState=myStatesMap.FindFromKey(nSp);
654         
655         if (aState==BooleanOperations_IN) {
656           const TopoDS_Shape& aSplit=aDS.Shape(nSp);
657           TopoDS_Edge aSS=TopoDS::Edge(aSplit);
658           //
659           if (!BOPTools_Tools2D::HasCurveOnSurface(aSS, aF1FWD)) {
660             continue;
661           }
662           //
663           aSS.Orientation(anOr);
664           //
665           aWES.AddStartElement (aSS);
666           //
667           if (BRep_Tool::IsClosed(aSS, aF2FWD)){
668             TopoDS_Shape EE=aSS.Reversed();
669             aWES.AddStartElement (EE);
670           }
671         }
672       }
673     }
674     else {
675       //>>>
676       if (!myStatesMap.Contains(nE)) {
677         continue;
678       }
679       //>>>
680       aState=myStatesMap.FindFromKey(nE);
681       if (aState==BooleanOperations_IN) {
682         TopoDS_Edge aSS=TopoDS::Edge(anE);
683         //
684         aWES.AddStartElement (aSS);
685       }
686     }
687   } // end of for (; anExp.More(); anExp.Next()) {
688   
689   PrepareOnParts(nF1, nF2, BOP_CUT);
690 }
691 //=======================================================================
692 // function: PrepareOnParts
693 // purpose: 
694 //=======================================================================
695   void BOP_SDFWESFiller::PrepareOnParts (const Standard_Integer nF1, 
696                                          const Standard_Integer nF2,
697                                          const BOP_Operation anOperation)
698 {
699   const BooleanOperations_ShapesDataStructure& aDS=myDSFiller->DS();
700   const BOPTools_PaveFiller& aPaveFiller=myDSFiller->PaveFiller();
701   BOPTools_PaveFiller* pPaveFiller=(BOPTools_PaveFiller*) &aPaveFiller;
702   BOPTools_CommonBlockPool& aCBPool=pPaveFiller->ChangeCommonBlockPool();
703   BOP_WireEdgeSet& aWES=*myWES;
704   //
705   const Handle(IntTools_Context)& aContext=pPaveFiller->Context();
706   //
707   Standard_Integer nE1, nE2, aNbSpON, nSp1, aBid, nSpTaken, nSp2, iRankF1, iRankF2;
708   Standard_Real aT1, aT2, aU, aV, aScPr;
709   Standard_Boolean bToReverse, bInternal1, bInternal2, bAdded;
710   
711   TopoDS_Edge aSS, aSSx;
712   TopoDS_Face aF1FWD, aF2FWD;
713   TopAbs_Orientation anOr, anOr2;
714
715   TColStd_ListOfInteger aLs;
716   TColStd_IndexedMapOfInteger aMap;
717   TopTools_IndexedMapOfShape aM;
718   TopTools_MapOfShape aMFence;//xft
719   //
720   gp_Vec aN1, aN2, aTau1, aTau2, aBiN1, aBiN2;
721   TopExp_Explorer anExpF1, anExpF2;
722   //
723   // Source faces
724   iRankF1=aDS.Rank(nF1);
725   iRankF2=aDS.Rank(nF2);
726   //
727   PrepareFaces(nF1, nF2, aF1FWD, aF2FWD);
728   //
729   myRejectedOnParts.Clear();//xft
730   //
731   anExpF1.Init(aF1FWD, TopAbs_EDGE);
732   for (; anExpF1.More(); anExpF1.Next()) {
733     const TopoDS_Edge& anE1=TopoDS::Edge(anExpF1.Current());
734     anOr=anE1.Orientation();
735     //
736     if (BRep_Tool::Degenerated(anE1)){
737       continue;
738     }
739     //
740     nE1=aDS.ShapeIndex(anE1, iRankF1); 
741
742     anExpF2.Init(aF2FWD, TopAbs_EDGE);
743     for (; anExpF2.More(); anExpF2.Next()) {
744       const TopoDS_Edge& anE2=TopoDS::Edge(anExpF2.Current());
745       anOr2=anE2.Orientation();
746       //
747       if (BRep_Tool::Degenerated(anE2)){
748         continue;
749       }
750       //
751       nE2=aDS.ShapeIndex(anE2, iRankF2);
752       aLs.Clear();
753       pPaveFiller->SplitsOnEdge(nE1, nE2, aLs);
754       
755       aNbSpON=aLs.Extent();
756       if (!aNbSpON) {
757         continue;
758       }
759
760       aMap.Clear();
761       TColStd_ListIteratorOfListOfInteger anItLs(aLs);
762       for (; anItLs.More(); anItLs.Next()) {
763         aBid=anItLs.Value();
764         aMap.Add(aBid);
765       }
766
767       BOPTools_ListOfCommonBlock& aLCB=aCBPool(aDS.RefEdge(nE1));
768       BOPTools_ListIteratorOfListOfCommonBlock anItCB(aLCB);
769       for (; anItCB.More(); anItCB.Next()) {
770         bAdded=Standard_False;//xft
771         BOPTools_CommonBlock& aCB=anItCB.Value();
772         // Pave Block from which new edge will be taken
773         const BOPTools_PaveBlock& aPB=aCB.PaveBlock1();
774         nSpTaken=aPB.Edge();
775         const TopoDS_Shape& aSpTaken=aDS.Shape(nSpTaken);
776         //
777         BOPTools_PaveBlock& aPB1=aCB.PaveBlock1(nE1);
778         nSp1=aPB1.Edge();
779         
780         if (aMap.Contains(nSp1)) {
781           BOPTools_PaveBlock& aPB2=aCB.PaveBlock2(nE1);
782           nSp2=aPB2.Edge();
783           //
784           //
785           //iiiiiiiiiiiiiiiii Tue Dec 25 15:10:09 2001 iiiiii
786           //
787           // Internal eges' processing
788           bInternal1=(anOr ==TopAbs_INTERNAL);
789           bInternal2=(anOr2==TopAbs_INTERNAL);
790           //
791           if (bInternal1 || bInternal2) {
792             aSS=TopoDS::Edge(aDS.Shape(nSpTaken));
793             // a.
794             if (bInternal1 && bInternal2) {
795               if (anOperation==BOP_COMMON) {
796                 aWES.AddStartElement (aSS);
797                 bAdded=Standard_True;//xft
798               }
799             }
800             // b.
801             else { // else x 
802               if (bInternal1 && !bInternal2) {
803                 if (nSpTaken==nSp1) {
804                   aSS.Orientation(TopAbs_FORWARD);
805                   aSSx=TopoDS::Edge(aDS.Shape(nSp2));
806                   aSSx.Orientation(anOr2);
807                   //
808                   bToReverse=BOPTools_Tools3D::IsSplitToReverse1 (aSSx, aSS, aContext);
809                   //
810                   if (bToReverse) {
811                     aSS.Reverse();
812                   }
813                 }
814                 else {//nSpTaken!=nSp1
815                   aSS.Orientation(anOr2);
816                 }
817               }
818               // c.
819               else if (!bInternal1 && bInternal2) {
820                 if (nSpTaken==nSp2) {
821                   aSS.Orientation(TopAbs_FORWARD);
822                   aSSx=TopoDS::Edge(aDS.Shape(nSp1));
823                   aSSx.Orientation(anOr);
824                   //
825                   bToReverse=BOPTools_Tools3D::IsSplitToReverse1 (aSSx, aSS, aContext);
826                   //
827                   if (bToReverse) {
828                     aSS.Reverse();
829                   }
830                 }
831                 else {//nSpTaken!=nSp2
832                   aSS.Orientation(anOr);
833                 }
834               }
835               // writting
836               if (anOperation==BOP_COMMON) {
837                 aWES.AddStartElement (aSS);
838                 bAdded=Standard_True;//xft
839               }
840               if (anOperation==BOP_CUT) { 
841                 aSS.Reverse();
842                 aWES.AddStartElement (aSS);
843                 bAdded=Standard_True;//xft
844               }
845             } // else x 
846             continue;
847           }  
848           //
849           //iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii
850           //
851           //
852           const BOPTools_PointBetween &aPbn1=aPB1.PointBetween();
853           aT1=aPbn1.Parameter();
854           BOPTools_Tools2D::EdgeTangent(anE1, aT1, aTau1);
855           
856           BOPTools_Tools2D::PointOnSurface(anE1, aF1FWD, aT1, aU, aV);
857           BOPTools_Tools2D::FaceNormal(aF1FWD, aU, aV, aN1);
858           aBiN1=aN1^aTau1;
859           
860           const BOPTools_PointBetween &aPbn2=aPB2.PointBetween();
861           aT2=aPbn2.Parameter();
862           BOPTools_Tools2D::EdgeTangent(anE2, aT2, aTau2);
863           
864           BOPTools_Tools2D::PointOnSurface(anE2, aF2FWD, aT2, aU, aV);
865           BOPTools_Tools2D::FaceNormal(aF2FWD, aU, aV, aN2);
866           aBiN2=aN2^aTau2;
867
868           aScPr=aBiN1*aBiN2;
869           //
870           if (aScPr < 0.) {
871             if (anOperation==BOP_CUT) { 
872               
873               if (nSpTaken==nSp1) {
874                 aSS=TopoDS::Edge(aDS.GetShape(nSp1));
875                 aSS.Orientation(anOr);
876               }
877               
878               else {
879                 const TopoDS_Shape& aSp1=aDS.Shape(nSp1);
880                 TopoDS_Edge aSpE1=TopoDS::Edge(aSp1);
881                 aSpE1.Orientation(anOr);
882
883                 const TopoDS_Shape& aSp2=aDS.Shape(nSp2);
884                 TopoDS_Edge aSpE2=TopoDS::Edge(aSp2);
885                 //
886                 bToReverse=BOPTools_Tools3D::IsSplitToReverse1 (aSpE1, aSpE2, aContext);
887                 //
888                 if (bToReverse) {
889                   aSpE2.Reverse();
890                 }
891                 aSS=aSpE2;
892               }
893               // modified by NIZHNY-MKK  Thu May 29 12:39:32 2003.BEGIN
894               if (BRep_Tool::IsClosed(anE1, aF1FWD) && (!aSS.IsSame(anE1))) {
895                 Standard_Boolean areverse = Standard_False;
896                 BOPTools_Tools3D::DoSplitSEAMOnFace(aSS, anE1, aF1FWD, areverse);
897               }
898
899               if(BRep_Tool::IsClosed(anE2, aF2FWD) && (!aSS.IsSame(anE2))) {
900                 Standard_Boolean areverse = Standard_False;
901                 BOPTools_Tools3D::DoSplitSEAMOnFace(aSS, anE2, aF2FWD, areverse);
902               }
903               // modified by NIZHNY-MKK  Thu May 29 12:39:35 2003.END
904               //
905               if (BRep_Tool::IsClosed(anE1, aF1FWD) &&
906                   BRep_Tool::IsClosed(anE2, aF2FWD)){
907                 //
908                 Standard_Boolean bIsTakenSp1;
909                 TopoDS_Edge aSpE1Seam11, aSpE1Seam21;
910
911                 bIsTakenSp1=(nSpTaken==nSp1);
912                 aSpE1Seam11=TopoDS::Edge(aDS.Shape(nSp1));
913                 aSpE1Seam21=TopoDS::Edge(aDS.Shape(nSp2));
914                 //
915                 if (aM.Contains(aSpE1Seam11)){
916                   continue;
917                 }
918                 aM.Add(aSpE1Seam11);
919                 //
920                 if (aM.Contains(aSpE1Seam21)){
921                   continue;
922                 }
923                 aM.Add(aSpE1Seam21);
924                 //
925                 TreatSDSeams (aSpE1Seam11, aT1, aF1FWD, 
926                               aSpE1Seam21, aT2, aF2FWD,
927                               bIsTakenSp1, aWES,
928                               aContext);
929                 //
930                 continue;
931               }
932               //
933               aWES.AddStartElement (aSS);
934               bAdded=Standard_True;//xft
935             } 
936             
937           }
938           
939           else {
940             if (anOperation==BOP_COMMON) {
941               
942               if (nSpTaken==nSp1) {
943                 aSS=TopoDS::Edge(aDS.GetShape(nSp1));
944                 aSS.Orientation(anOr);
945               }
946               
947               else {
948                 const TopoDS_Shape& aSp1=aDS.Shape(nSp1);
949                 TopoDS_Edge aSpE1=TopoDS::Edge(aSp1);
950                 aSpE1.Orientation(anOr);
951
952                 const TopoDS_Shape& aSp2=aDS.Shape(nSp2);
953                 TopoDS_Edge aSpE2=TopoDS::Edge(aSp2);
954                 //
955                 bToReverse=BOPTools_Tools3D::IsSplitToReverse1 (aSpE1, aSpE2, aContext);
956                 //
957                 if (bToReverse) {
958                   aSpE2.Reverse();
959                 }
960                 aSS=aSpE2;
961                 //
962                 if (BRep_Tool::IsClosed(aSpE1, aF1FWD)) {
963                   //
964                   if (aM.Contains(aSpE2)){
965                     continue;
966                   }
967                   aM.Add(aSpE2);
968                   //
969                   if (!BRep_Tool::IsClosed(aSpE2, aF1FWD)) {
970                     BOPTools_Tools3D::DoSplitSEAMOnFace (aSpE2, aF1FWD);
971                   }
972                   aWES.AddStartElement (aSpE2);
973                   aSpE2.Reverse();
974                   aWES.AddStartElement (aSpE2);
975                   bAdded=Standard_True; //xft
976                   continue;  
977                 }
978                 //
979               }
980               //
981               aWES.AddStartElement (aSS);
982               bAdded=Standard_True; //xft
983             }// if (anOperation==BOP_COMMON) {
984           }// else {
985           if (!bAdded) {
986             if(aMFence.Add(aSpTaken)) { 
987               myRejectedOnParts.Append(aSpTaken);
988             }
989           }
990         }// if (aMap.Contains(nSp1)) { 
991       }// for (; anItCB.More(); anItCB.Next()) {
992     }// for (; anExpF2.More(); anExpF2.Next()) {
993   }//for (; anExpF1.More(); anExpF1.Next()) {
994 }
995
996 //=======================================================================
997 // function: PrepareFaces
998 // purpose: 
999 //=======================================================================
1000   void BOP_SDFWESFiller::PrepareFaces   (const Standard_Integer nF1, 
1001                                          const Standard_Integer nF2, 
1002                                          TopoDS_Face& aF1FWD,
1003                                          TopoDS_Face& aF2FWD) const
1004 {
1005   const BooleanOperations_ShapesDataStructure& aDS=myDSFiller->DS();
1006   TopAbs_Orientation anOr1, anOr2;
1007
1008   const TopoDS_Shape& aF1=aDS.GetShape(nF1); 
1009   aF1FWD=TopoDS::Face(aF1);
1010   anOr1=aF1.Orientation();
1011
1012   const TopoDS_Shape& aF2=aDS.GetShape(nF2);
1013   aF2FWD=TopoDS::Face(aF2);
1014   anOr2=aF2.Orientation();
1015
1016   aF1FWD.Orientation(TopAbs_FORWARD);
1017
1018   if (mySenseFlag==1) {
1019     if      (anOr1==TopAbs_FORWARD   && anOr2==TopAbs_FORWARD) {
1020       aF2FWD.Orientation(TopAbs_FORWARD);
1021     }
1022     else if (anOr1==TopAbs_REVERSED  && anOr2==TopAbs_REVERSED) {
1023       aF2FWD.Orientation(TopAbs_FORWARD);
1024     }
1025     else if (anOr1==TopAbs_FORWARD  && anOr2==TopAbs_REVERSED) {
1026       aF2FWD.Orientation(TopAbs_REVERSED);
1027     }
1028     else if (anOr1==TopAbs_REVERSED  && anOr2==TopAbs_FORWARD) {
1029       aF2FWD.Orientation(TopAbs_REVERSED);
1030     }
1031   }
1032
1033   else{
1034     if      (anOr1==TopAbs_FORWARD   && anOr2==TopAbs_FORWARD) {
1035       aF2FWD.Orientation(TopAbs_REVERSED);
1036     }
1037     else if (anOr1==TopAbs_REVERSED  && anOr2==TopAbs_REVERSED) {
1038       aF2FWD.Orientation(TopAbs_REVERSED);
1039     }
1040     else if (anOr1==TopAbs_FORWARD  && anOr2==TopAbs_REVERSED) {
1041       aF2FWD.Orientation(TopAbs_FORWARD);
1042     }
1043     else if (anOr1==TopAbs_REVERSED  && anOr2==TopAbs_FORWARD) {
1044       aF2FWD.Orientation(TopAbs_FORWARD);
1045     }
1046   }
1047 }
1048 //
1049 //=======================================================================
1050 // function: AssignDEStates
1051 // purpose: 
1052 //======================================================================= 
1053   void BOP_SDFWESFiller::AssignDEStates(const Standard_Integer nF1,
1054                                         const Standard_Integer nF2) 
1055 {
1056   const BooleanOperations_ShapesDataStructure& aDS=myDSFiller->DS();
1057   
1058   Standard_Integer nE1, iRankF1;
1059   TopExp_Explorer anExpF1;
1060
1061   iRankF1=aDS.Rank(nF1);
1062
1063   const TopoDS_Face& aF1=TopoDS::Face(aDS.Shape(nF1));
1064
1065   anExpF1.Init(aF1, TopAbs_EDGE);
1066   for (; anExpF1.More(); anExpF1.Next()) {
1067     const TopoDS_Edge& anE1=TopoDS::Edge(anExpF1.Current());
1068     //
1069     if (!BRep_Tool::Degenerated(anE1)){
1070       continue;
1071     }
1072     //
1073     nE1=aDS.ShapeIndex(anE1, iRankF1);
1074     AssignDEStates (nF1, nE1, nF2); 
1075   }
1076 }
1077
1078 //=======================================================================
1079 // function: AssignDEStates
1080 // purpose: 
1081 //======================================================================= 
1082   void BOP_SDFWESFiller::AssignDEStates(const Standard_Integer nFD,
1083                                         const Standard_Integer nED, 
1084                                         const Standard_Integer nF2) 
1085 {
1086   const BooleanOperations_ShapesDataStructure& aDS=myDSFiller->DS();
1087   const BOPTools_PaveFiller& aPaveFiller=myDSFiller->PaveFiller();
1088   BOPTools_PaveFiller* pPaveFiller=(BOPTools_PaveFiller*) &aPaveFiller;
1089   const BOPTools_SplitShapesPool& aSplitShapesPool=aPaveFiller.SplitShapesPool();
1090   //
1091   const BOPTools_ListOfPaveBlock& aSplitEdges=aSplitShapesPool(aDS.RefEdge(nED));
1092   //
1093   const Handle(IntTools_Context)& aContext=pPaveFiller->Context();
1094   const TopoDS_Edge& aDE=TopoDS::Edge(aDS.Shape(nED));
1095   const TopoDS_Face& aDF=TopoDS::Face(aDS.Shape(nFD));
1096   const TopoDS_Face& aFaceReference=TopoDS::Face(aDS.Shape(nF2));
1097   //
1098   Standard_Boolean bIsValidPoint;
1099   Standard_Integer nSp;
1100   Standard_Real aT, aT1, aT2;
1101   TopAbs_State aState;
1102   TopoDS_Face aF;
1103   gp_Pnt2d aPx2DNear;
1104   gp_Pnt aPxNear;
1105   //
1106   aF=aDF;
1107   aF.Orientation(TopAbs_FORWARD);
1108   
1109   BOPTools_ListIteratorOfListOfPaveBlock aPBIt(aSplitEdges);
1110   for (; aPBIt.More(); aPBIt.Next()) {
1111     BOPTools_PaveBlock& aPB=aPBIt.Value();
1112     
1113     nSp=aPB.Edge();
1114     const TopoDS_Edge& aSp=TopoDS::Edge(aDS.Shape(nSp));
1115     
1116     aPB.Parameters(aT1, aT2);
1117     aT=IntTools_Tools::IntermediatePoint(aT1, aT2);
1118
1119     TopoDS_Edge aDERight, aSpRight;
1120     aDERight=aDE;
1121     aSpRight=aSp;
1122
1123     BOPTools_Tools3D::OrientEdgeOnFace (aDE, aF, aDERight);
1124     aSpRight.Orientation(aDERight.Orientation());
1125     //
1126     BOPTools_Tools3D::PointNearEdge(aSpRight, aDF, aT, aPx2DNear, aPxNear);
1127     //
1128     aState=TopAbs_OUT;
1129     //
1130     bIsValidPoint=aContext->IsValidPointForFace(aPxNear, aFaceReference, 1.e-3);
1131     //
1132     if (bIsValidPoint) {
1133       aState=TopAbs_IN;
1134     }
1135     //
1136     BooleanOperations_StateOfShape aSt;
1137     
1138     aSt=BOPTools_SolidStateFiller::ConvertState(aState);
1139     if (myStatesMap.Contains(nSp)) {
1140       BooleanOperations_StateOfShape& aBooState=myStatesMap.ChangeFromKey(nSp);
1141       aBooState=aSt;
1142     }
1143     else {
1144       myStatesMap.Add(nSp, aSt);
1145     }
1146   }
1147 }
1148
1149 //=======================================================================
1150 // function: UpdateDEStates3D
1151 // purpose: 
1152 //======================================================================= 
1153   void BOP_SDFWESFiller::UpdateDEStates3D()
1154 {
1155   BooleanOperations_ShapesDataStructure* pDS=
1156     (BooleanOperations_ShapesDataStructure*)&myDSFiller->DS();
1157   
1158   Standard_Integer i, aNb, nSp;
1159   BooleanOperations_StateOfShape aSt;
1160
1161   aNb=myStatesMap.Extent();
1162   for (i=1; i<=aNb; i++) {
1163     nSp=myStatesMap.FindKey(i);
1164     aSt=pDS->GetState(nSp);
1165     aSt=BooleanOperations_UNKNOWN;
1166     pDS->SetState(nSp, aSt);
1167   }
1168 }
1169 //
1170 #include <Geom2d_Curve.hxx>
1171 #include <gp_Pnt2d.hxx>
1172
1173 //=======================================================================
1174 // function: TreatSDSeams
1175 // purpose: 
1176 //=======================================================================
1177 void TreatSDSeams (const TopoDS_Edge& aSpE1Seam11,
1178                    const Standard_Real aT1,
1179                    const TopoDS_Face& aF1FWD,
1180         
1181                    const TopoDS_Edge& aSpE1Seam21,
1182                    const Standard_Real aT2,
1183                    const TopoDS_Face& aF2FWD,
1184                    
1185                    const Standard_Boolean bIsTakenSp1,
1186                    BOP_WireEdgeSet& aWES,
1187                    const Handle(IntTools_Context)& aContext)
1188 {
1189   Standard_Boolean bIsValidSeam11, bIsValidSeam12, 
1190                    bIsValidSeam21, bIsValidSeam22;
1191   Standard_Real aScPr;
1192   TopoDS_Edge aSS, aSpE1Seam12,aSpE1Seam22;
1193   gp_Dir aDB11, aDB12, aDB21, aDB22;
1194             
1195   aSpE1Seam12=TopoDS::Edge(aSpE1Seam11.Reversed());
1196   aSpE1Seam22=TopoDS::Edge(aSpE1Seam21.Reversed());
1197             //
1198   if (!bIsTakenSp1) {
1199     BOPTools_Tools3D::DoSplitSEAMOnFace (aSpE1Seam21, aF1FWD);
1200     aSpE1Seam22=TopoDS::Edge(aSpE1Seam21.Reversed());
1201   }
1202   //
1203   bIsValidSeam11=IsValidSeam(aSpE1Seam11, aF1FWD, aT1, aContext);
1204   bIsValidSeam12=IsValidSeam(aSpE1Seam12, aF1FWD, aT1, aContext);
1205   bIsValidSeam21=IsValidSeam(aSpE1Seam21, aF2FWD, aT2, aContext);
1206   bIsValidSeam22=IsValidSeam(aSpE1Seam22, aF2FWD, aT2, aContext);
1207   // 1
1208   if (bIsValidSeam11 && bIsValidSeam12) {
1209     BOPTools_Tools3D::GetBiNormal(aSpE1Seam11, aF1FWD, aT1, aDB11);
1210     BOPTools_Tools3D::GetBiNormal(aSpE1Seam12, aF1FWD, aT1, aDB12);
1211     // 1.1
1212     if (bIsValidSeam21 && !bIsValidSeam22) {
1213       BOPTools_Tools3D::GetBiNormal(aSpE1Seam21, aF2FWD, aT2, aDB21);
1214       aScPr=aDB11*aDB21;
1215       if (aScPr<0.) {
1216         if (bIsTakenSp1) {
1217           aSS=aSpE1Seam11;
1218         }
1219         else {
1220           //aSS=aSpE1Seam21;
1221           CorrespondantSeam(aSpE1Seam11, aT1, 
1222                             aSpE1Seam21, aSpE1Seam22, aT2, 
1223                             aF1FWD, aSS);
1224         }
1225       }
1226       else { //if (aScPr>0.)
1227         if (bIsTakenSp1) {
1228           aSS=aSpE1Seam12;
1229         }
1230         else {
1231           //aSS=aSpE1Seam22;
1232           CorrespondantSeam(aSpE1Seam12, aT1, 
1233                             aSpE1Seam21, aSpE1Seam22, aT2, 
1234                             aF1FWD, aSS);
1235         }
1236       }
1237       aWES.AddStartElement (aSS);
1238     } //if (bIsValidSeam21 && !bIsValidSeam22)
1239     //  
1240     // 1.2      
1241     if (!bIsValidSeam21 && bIsValidSeam22) {
1242       BOPTools_Tools3D::GetBiNormal(aSpE1Seam22, aF2FWD, aT2, aDB22);
1243       aScPr=aDB11*aDB22;
1244       if (aScPr<0.) {
1245         if (bIsTakenSp1) {
1246           aSS=aSpE1Seam11;
1247         }
1248         else {
1249           //aSS=aSpE1Seam22;
1250           CorrespondantSeam(aSpE1Seam11, aT1, 
1251                             aSpE1Seam21, aSpE1Seam22, aT2, 
1252                             aF1FWD, aSS);
1253         }
1254       }
1255       else {//if (aScPr>0.)
1256         if (bIsTakenSp1) {
1257           aSS=aSpE1Seam12;
1258         }
1259         else {
1260           //aSS=aSpE1Seam21;
1261           CorrespondantSeam(aSpE1Seam12, aT1, 
1262                             aSpE1Seam21, aSpE1Seam22, aT2, 
1263                             aF1FWD, aSS);
1264         }
1265       }
1266       aWES.AddStartElement (aSS);
1267     }// if (!bIsValidSeam21 && bIsValidSeam22)
1268   } //if (bIsValidSeam11 && bIsValidSeam12)
1269 }
1270
1271 //=======================================================================
1272 // function: IsValidSeam
1273 // purpose: 
1274 //======================================================================= 
1275   Standard_Boolean IsValidSeam(const TopoDS_Edge& aE,
1276                                const TopoDS_Face& aF,
1277                                const Standard_Real aT,
1278                                const Handle(IntTools_Context)& aContext)
1279 {
1280   Standard_Boolean bIsPointInOnFace;
1281   gp_Pnt2d aPx2DNear;
1282   gp_Pnt aPxNear;
1283
1284   BOPTools_Tools3D::PointNearEdge(aE, aF, aT, aPx2DNear, aPxNear);
1285   //
1286   bIsPointInOnFace=aContext->IsPointInOnFace(aF, aPx2DNear);
1287   return bIsPointInOnFace;
1288 }
1289 //=======================================================================
1290 // function: CorrespondantSeam
1291 // purpose: 
1292 //======================================================================= 
1293   void CorrespondantSeam(const TopoDS_Edge& aSpE1Seam11,
1294                          const Standard_Real aT1,
1295                          const TopoDS_Edge& aSpE1Seam21,
1296                          const TopoDS_Edge& aSpE1Seam22,
1297                          const Standard_Real aT2,
1298                          const TopoDS_Face& aF1FWD,
1299                          TopoDS_Edge& aSS)
1300                                       
1301 {
1302   Standard_Real a, b, aD1121, aD1122, aTol=1.e-7;
1303   Handle(Geom2d_Curve) aC2DSeam11, aC2DSeam21, aC2DSeam22;
1304   gp_Pnt2d aP2D11, aP2D21, aP2D22;
1305
1306   aC2DSeam11=BRep_Tool::CurveOnSurface(aSpE1Seam11, aF1FWD, a, b);
1307   aC2DSeam11->D0(aT1, aP2D11);
1308
1309   aC2DSeam21=BRep_Tool::CurveOnSurface(aSpE1Seam21, aF1FWD, a, b);
1310   aC2DSeam21->D0(aT2, aP2D21);
1311
1312   aC2DSeam22=BRep_Tool::CurveOnSurface(aSpE1Seam22, aF1FWD, a, b);
1313   aC2DSeam22->D0(aT2, aP2D22);
1314
1315   aD1121=aP2D11.Distance(aP2D21);
1316   aD1122=aP2D11.Distance(aP2D22);
1317   
1318   aSS=aSpE1Seam22;
1319   if (aD1121<aTol) {
1320     aSS=aSpE1Seam21;
1321   }
1322 }