0023024: Update headers of OCCT files
[occt.git] / src / BRepTools / BRepTools_Quilt.cxx
1 // Created on: 1994-12-23
2 // Created by: Remi LEQUETTE
3 // Copyright (c) 1994-1999 Matra Datavision
4 // Copyright (c) 1999-2012 OPEN CASCADE SAS
5 //
6 // The content of this file is subject to the Open CASCADE Technology Public
7 // License Version 6.5 (the "License"). You may not use the content of this file
8 // except in compliance with the License. Please obtain a copy of the License
9 // at http://www.opencascade.org and read it completely before using this file.
10 //
11 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
12 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
13 //
14 // The Original Code and all software distributed under the License is
15 // distributed on an "AS IS" basis, without warranty of any kind, and the
16 // Initial Developer hereby disclaims all such warranties, including without
17 // limitation, any warranties of merchantability, fitness for a particular
18 // purpose or non-infringement. Please see the License for the specific terms
19 // and conditions governing the rights and limitations under the License.
20
21
22
23 #include <BRepTools_Quilt.ixx>
24
25 #include <TopoDS.hxx>
26 #include <TopoDS_Face.hxx>
27 #include <TopoDS_Wire.hxx>
28 #include <TopoDS_Shape.hxx>
29 #include <TopoDS_Shell.hxx>
30 #include <TopoDS_Compound.hxx>
31 #include <TopoDS_Iterator.hxx>
32
33 #include <TopTools_DataMapIteratorOfDataMapOfShapeShape.hxx>
34 #include <TopTools_DataMapOfShapeShape.hxx>
35 #include <TopExp_Explorer.hxx>
36
37 #include <Geom2d_Curve.hxx>
38
39 #include <BRep_Builder.hxx>
40 #include <BRep_Tool.hxx>
41 #include <TopTools_MapOfShape.hxx>
42 #include <TopoDS_Shape.hxx>
43 #include <TopTools_MapIteratorOfMapOfShape.hxx>
44 #include <TopTools_ListOfShape.hxx>
45 #include <TopTools_IndexedDataMapOfShapeShape.hxx>
46
47 //=======================================================================
48 //function : BRepTools_Quilt
49 //purpose  : 
50 //=======================================================================
51
52 BRepTools_Quilt::BRepTools_Quilt() : hasCopy(Standard_False)
53 {
54 }
55
56 //=======================================================================
57 //function : Add
58 //purpose  : 
59 //=======================================================================
60 static Standard_Boolean NeedCopied(const TopoDS_Shape& theShape,const TopTools_IndexedDataMapOfShapeShape& myBounds)
61 {
62     // test if the shape must be copied
63     // i.e. it contains a bound subshape
64   Standard_Boolean IsCopied = Standard_False;
65   TopoDS_Iterator itv(theShape) ;
66   for ( ; itv.More(); itv.Next()) {
67     if (myBounds.Contains(itv.Value())) {
68       IsCopied = Standard_True;
69       break;
70     }
71   }
72   return IsCopied;
73 }
74 static void CopyShape(const TopoDS_Edge& E,TopTools_IndexedDataMapOfShapeShape& myBounds)
75 {
76   TopoDS_Edge NE = E;
77   NE.EmptyCopy();
78   NE.Orientation(TopAbs_FORWARD);
79   BRep_Builder B;
80   // add the edges
81   TopoDS_Iterator itv;
82   itv.Initialize(E,Standard_False) ; //TCollection_DataMap
83   for ( ; itv.More(); itv.Next()) {
84     const TopoDS_Shape& V = itv.Value();
85     if (myBounds.Contains(V)) {
86       B.Add(NE,myBounds.FindFromKey(V).Oriented(V.Orientation()));
87     }
88     else {
89       B.Add(NE,V);
90     }
91   }
92   // set the 3d range
93   Standard_Real f,l;
94   BRep_Tool::Range(E,f,l);
95   B.Range(NE,f,l);
96   myBounds.Add(E,NE.Oriented(TopAbs_FORWARD));
97 }
98 /*static void CopyShape(const TopoDS_Wire& W,TopTools_DataMapOfShapeShape& myBounds)
99 {
100   TopoDS_Wire NW;
101   B.MakeWire(NW);
102   TopoDS_Iterator ite(W,Standard_False);
103   for ( ; ite.More(); ite.Next()){
104     const TopoDS_Edge& E = TopoDS::Edge(ite.Value());
105     TopAbs_Orientation OE = E.Orientation();
106     if (myBounds.IsBound(E)) {
107       TopoDS_Edge& NE = TopoDS::Edge(myBounds(E));
108       B.Add(NW,NE.Oriented(OE));
109     }
110     else
111       B.Add(NW,E);
112   }
113   NW.Orientation(W.Orientation());
114   myBounds.Bind(W,NW);
115 }*/
116 void BRepTools_Quilt::Add(const TopoDS_Shape& S)
117 {
118   //cout <<" Version of sewing with free edges"<<endl;
119   // Binds all the faces of S
120   //  - to the face itself if it is not copied
121   //  - to the copy if it is copied
122   if(myBounds.Contains(S)) return;
123   BRep_Builder B;
124   for (TopExp_Explorer wex(S,TopAbs_WIRE,TopAbs_FACE); wex.More(); wex.Next()) 
125      myBounds.Add(wex.Current(),wex.Current());
126   
127   for (TopExp_Explorer eex(S,TopAbs_EDGE,TopAbs_WIRE); eex.More(); eex.Next())
128     myBounds.Add(eex.Current(),eex.Current());
129   
130   for (TopExp_Explorer vex(S,TopAbs_VERTEX,TopAbs_EDGE); vex.More(); vex.Next())
131     myBounds.Add(vex.Current(),vex.Current());
132   
133     // explore the faces
134     for (TopExp_Explorer fex(S,TopAbs_FACE); fex.More(); fex.Next()) {
135       
136       // explore the edges of the face and try to copy them
137       // if one edge is bound the face must be copied
138       
139       Standard_Boolean copyFace = Standard_False;
140       const TopoDS_Face& F = TopoDS::Face(fex.Current());
141       
142       if (hasCopy) { // if their is no binding, do not test for copy
143         
144         for (TopExp_Explorer fed(F,TopAbs_EDGE); fed.More(); fed.Next()) {
145           
146           if (myBounds.Contains(fed.Current())) {
147             copyFace = Standard_True;
148           }
149           else {
150             // test if the edge must be copied
151             // i.e. it contains a bound vertex
152             
153             Standard_Boolean copyEdge = NeedCopied(fed.Current(),myBounds);
154             //Standard_Boolean copyEdge = Standard_False;
155             const TopoDS_Edge& E = TopoDS::Edge(fed.Current());
156             
157             // TopoDS_Iterator itv(E) ;
158             // for ( ; itv.More(); itv.Next()) {
159               // if (myBounds.IsBound(itv.Value())) {
160                 //      copyEdge = Standard_True;
161                 // break;
162                 //     }
163               //  }
164             
165             if (copyEdge) {
166               
167               // copy of an edge
168               
169               copyFace = Standard_True;
170               CopyShape(E,myBounds);
171               //TopoDS_Edge NE = E; //gka version for free edges
172               //NE.EmptyCopy();
173               
174               //NE.Orientation(TopAbs_FORWARD);
175               // add the edges
176               //itv.Initialize(E,Standard_False) ;
177               //for ( ; itv.More(); itv.Next()) {
178                 //const TopoDS_Shape& V = itv.Value();
179                 //if (myBounds.IsBound(V)) {
180                  // B.Add(NE,myBounds(V).Oriented(V.Orientation()));
181                 //}
182                 //else {
183                  // B.Add(NE,V);
184                 //}
185               //}
186               // set the 3d range
187               //Standard_Real f,l;
188               //BRep_Tool::Range(E,f,l);
189               //B.Range(NE,f,l);
190               
191               //myBounds.Bind(E,NE.Oriented(TopAbs_FORWARD));
192             }
193           }
194         }
195       }
196       
197       // NF will be the copy of F or F itself
198       TopoDS_Face NF = F;
199
200       if (copyFace) {
201
202         // copy of a face 
203         
204         NF.EmptyCopy();
205         NF.Orientation(TopAbs_FORWARD);
206         
207         for (TopoDS_Iterator itw(F,Standard_False); itw.More(); itw.Next()) {
208           const TopoDS_Wire& W = TopoDS::Wire(itw.Value());
209           
210           TopoDS_Wire NW;
211           B.MakeWire(NW);
212           TopoDS_Iterator ite(W,Standard_False);
213           Standard_Real   UFirst,ULast;
214           
215           // Reconstruction des wires.
216           
217           for ( ; ite.More(); ite.Next()){
218             const TopoDS_Edge& E = TopoDS::Edge(ite.Value());
219             TopAbs_Orientation OE = E.Orientation();
220             if (myBounds.Contains(E)) {
221               const TopoDS_Edge& NE = TopoDS::Edge(myBounds.FindFromKey(E));
222               // pcurve.
223               if (NE.Orientation() == TopAbs_FORWARD) {
224                 B.UpdateEdge(NE,
225                              BRep_Tool::CurveOnSurface(E,F,UFirst,ULast),
226                              F,BRep_Tool::Tolerance(E));
227               }
228               else {
229                 // Si NE est REVERSED 
230                 // => les curve3d n ont pas la meme orientation.
231                 // ( C est une convention cf BRepTools_Quilt.cdl. et la methode
232                 // Bind.)
233                 // => la PCurve de E sur F doit etre inversee.
234                 
235                 OE = TopAbs::Reverse(OE);
236                 Handle(Geom2d_Curve) CE = 
237                   BRep_Tool::CurveOnSurface(E,F,UFirst,ULast);
238                 Handle(Geom2d_Curve) NCE = CE->Reversed();
239                 B.UpdateEdge(NE,NCE,F,BRep_Tool::Tolerance(E));
240                 Standard_Real tmp = UFirst;
241                 UFirst = CE->ReversedParameter(ULast);
242                 ULast  = CE->ReversedParameter(tmp);
243               }
244               // pcurve range
245               B.Range(NE,F,UFirst,ULast);
246
247               B.Add(NW,NE.Oriented(OE));
248             }
249             else {
250               B.Add(NW,E);
251             }
252           }
253           NW.Orientation(W.Orientation());
254           B.Add(NF,NW);
255         }
256         NF.Orientation(F.Orientation());
257       }
258
259       // binds the face to itself or its copy
260       myBounds.Add(F,NF);
261     }
262   
263 }
264
265 //=======================================================================
266 //function : Bind
267 //purpose  : 
268 //=======================================================================
269
270 void BRepTools_Quilt::Bind(const TopoDS_Vertex& Vold, 
271                            const TopoDS_Vertex& Vnew)
272 {
273   if (!myBounds.Contains(Vold)) {
274     myBounds.Add(Vold,Vnew);
275   }
276 }
277
278 //=======================================================================
279 //function : Bind
280 //purpose  : 
281 //=======================================================================
282
283 void BRepTools_Quilt::Bind(const TopoDS_Edge& Eold, const TopoDS_Edge& Enew)
284 {
285   if (!myBounds.Contains(Eold)) {
286     TopoDS_Edge ENew = Enew;
287     if (IsCopied(Enew)) {
288       ENew = TopoDS::Edge(Copy(Enew));
289       ENew.Orientation(Enew.Orientation());
290     }
291     
292     if (Eold.Orientation() != ENew.Orientation()) {
293       myBounds.Add(Eold.Oriented(TopAbs_FORWARD),
294                     ENew.Oriented(TopAbs_REVERSED));
295     }
296     else {
297       myBounds.Add(Eold.Oriented(TopAbs_FORWARD),
298                     ENew.Oriented(TopAbs_FORWARD));
299     }  
300     // if new binding bind also the vertices
301     TopoDS_Iterator itold(Eold);
302     while (itold.More()) {
303       if (!myBounds.Contains(itold.Value())) {
304         // find the vertex of Enew with same orientation
305         TopAbs_Orientation anOrien = itold.Value().Orientation();
306         TopoDS_Iterator itnew(ENew);
307         while (itnew.More()) {
308           if (itnew.Value().Orientation() == anOrien) {
309             TopoDS_Vertex VNew = TopoDS::Vertex(itnew.Value());
310             if (IsCopied(VNew)) {
311               // if VNew has been copied take the copy
312               VNew = TopoDS::Vertex(Copy(VNew));
313             }
314             myBounds.Add(itold.Value(),VNew);
315             break;
316           }
317           itnew.Next();
318         }
319       }
320       itold.Next();
321     }
322     hasCopy = Standard_True;
323   }
324 }
325
326 //=======================================================================
327 //function : IsBound
328 //purpose  : 
329 //=======================================================================
330
331 Standard_Boolean BRepTools_Quilt::IsCopied(const TopoDS_Shape& S) const 
332 {
333   if (myBounds.Contains(S)) {
334     return !S.IsSame(myBounds.FindFromKey(S));
335   }
336   else
337     return Standard_False;
338 }
339
340 //=======================================================================
341 //function : Copy
342 //purpose  : 
343 //=======================================================================
344
345 const TopoDS_Shape& BRepTools_Quilt::Copy(const TopoDS_Shape& S) const 
346 {
347   Standard_NoSuchObject_Raise_if(!IsCopied(S),"BRepTools_Quilt::Copy");
348   return myBounds.FindFromKey(S);
349 }
350
351 //=======================================================================
352 //function : Shells
353 //purpose  : 
354 //=======================================================================
355
356 TopoDS_Shape BRepTools_Quilt::Shells() const 
357 {
358   // Outline of the algorithm
359   //
360   // In the map M we bind the free edges to their shells
361   // We explore all the faces in myBounds
362   // For each one we search the edges in the map and either :
363   //
364   // - Start a new shell if no edge is a free edge.
365   // - Add the face to an existing shell
366   // - Connect other shells if the face touch more than one shell
367
368   // In the Map M the Shell is bound withe the relative orientation of E 
369   // in the shell
370   // In the map MF we binb the face to its shell.
371   // In the Map MF the Shell is bound with the relative orientation of F 
372   // in the shell
373
374   TopTools_DataMapOfShapeShape M, MF;
375   BRep_Builder                 B;
376   TopoDS_Compound              result;
377
378   B.MakeCompound(result);
379   
380   TopTools_MapOfShape MapOtherShape; //gka
381   TopTools_MapOfShape EdgesFaces;
382   
383   // loop on the face in myBounds
384   //TopTools_DataMapIteratorOfDataMapOfShapeShape it(myBounds);
385
386   //while (it.More()) 
387   for(Standard_Integer ii =1; ii <= myBounds.Extent(); ii++) {
388     const TopoDS_Shape& Shape = myBounds.FindFromIndex(ii); //it.Value();
389     if (Shape.ShapeType() == TopAbs_FACE) {
390       for(TopExp_Explorer aExpEdg(Shape,TopAbs_EDGE); aExpEdg.More(); aExpEdg.Next()) //gka
391         EdgesFaces.Add(aExpEdg.Current());
392       
393       TopoDS_Shell       SH;
394       TopAbs_Orientation NewO;
395
396       TopExp_Explorer itf1( Shape,TopAbs_EDGE);
397       for ( ; itf1.More(); itf1.Next()) {
398         const TopoDS_Shape& E = itf1.Current();
399         if (M.IsBound(E)) {
400           SH = TopoDS::Shell(M(E));
401           if (SH.Orientation() == E.Orientation())
402             NewO = TopAbs::Reverse(Shape.Orientation());
403           else
404             NewO = Shape.Orientation(); 
405
406           MF.Bind (Shape,SH.Oriented(NewO));
407           break;
408         }
409       }
410
411       if (SH.IsNull()) {
412         // Create a new shell, closed. Add it to the result.
413         B.MakeShell(SH);
414         SH.Closed(Standard_True);
415         B.Add(result,SH);
416         MF.Bind (Shape,SH.Oriented(Shape.Orientation()));
417       }
418
419
420       // Add the face to the shell
421       SH.Free(Standard_True);
422 //      B.Add(SH.Oriented(TopAbs_FORWARD), F .Oriented(MF(F).Orientation()));
423       TopoDS_Shape arefShape = SH.Oriented(TopAbs_FORWARD) ;
424       B.Add( arefShape , Shape.Oriented(MF(Shape).Orientation()));
425
426       TopExp_Explorer itf(Shape.Oriented(TopAbs_FORWARD),TopAbs_EDGE);
427
428       for ( ;itf.More(); itf.Next()) {
429         const TopoDS_Edge& E = TopoDS::Edge(itf.Current());
430         
431         if (M.IsBound(E)) {
432           const TopoDS_Shape oldShell = M(E);
433           if (!oldShell.IsSame(SH)) {
434             // Fuse the old shell with the new one        
435             // Compare the orientation of E in SH and in oldshell.
436             TopAbs_Orientation anOrien = E.Orientation();
437             if (MF(Shape).Orientation() == TopAbs_REVERSED) 
438               anOrien = TopAbs::Reverse(anOrien);
439
440             Standard_Boolean Rev = (anOrien == oldShell.Orientation());
441             //if rev = True oldShell has to be reversed.
442
443             // Add the faces of oldShell in SH.
444             for (TopoDS_Iterator its(oldShell); its.More(); its.Next()) {
445               const TopoDS_Face Fo = TopoDS::Face(its.Value());
446               TopAbs_Orientation NewO;
447               // update the orientation of Fo in SH.
448               if (Rev) 
449                 NewO = TopAbs::Reverse(MF(Fo).Orientation());
450               else
451                 NewO = MF(Fo).Orientation();
452
453               MF.Bind(Fo,SH.Oriented(NewO));
454 //            B.Add  (SH.Oriented(TopAbs_FORWARD),Fo.Oriented(NewO));
455               TopoDS_Shape arefShape = SH.Oriented(TopAbs_FORWARD) ;
456               B.Add  ( arefShape ,Fo.Oriented(NewO));
457             }
458             // Rebind the free edges of the old shell to the new shell
459             //gka BUG 6491
460             TopExp_Explorer aexp(SH,TopAbs_EDGE);
461             for( ; aexp.More(); aexp.Next()) {
462             //for (TopTools_DataMapIteratorOfDataMapOfShapeShape itm(M);
463 //               itm.More(); ) {
464               if(!M.IsBound(aexp.Current()))
465                  continue;
466               TopoDS_Shape ae = aexp.Current();
467               TopoDS_Shape as = M.Find(ae);
468               if (as.IsSame(oldShell)) {
469                 // update the orientation of free edges in SH.
470                 if (Rev)
471                   NewO = TopAbs::Reverse(as.Orientation());
472                 else
473                   NewO = as.Orientation();
474                 
475                 M.Bind(ae,SH.Oriented(NewO));
476               }
477             }
478             // remove the old shell from the result
479             B.Remove(result,oldShell.Oriented(TopAbs_FORWARD));
480           }
481           // Test if SH is always orientable.
482           TopAbs_Orientation anOrien   =  E.Orientation();
483           if (MF(Shape).Orientation() == TopAbs_REVERSED)
484             anOrien = TopAbs::Reverse(anOrien);
485
486           if (M(E).Orientation() == anOrien)
487             SH.Orientable(Standard_False);
488           
489           // remove the edge from M (no more a free edge)           
490           M.UnBind(E);
491         }
492         else {
493           NewO = E.Orientation();
494           if (MF(Shape).Orientation() == TopAbs_REVERSED)
495             NewO = TopAbs::Reverse(NewO);
496           if(!E.IsNull())
497             M.Bind(E,SH.Oriented(NewO));
498           else
499             continue;
500         }
501       }
502
503       // freeze the shell
504       SH.Free(Standard_False);
505     }
506     else 
507      MapOtherShape.Add(Shape); 
508     
509     //it.Next();
510   }
511  
512   // Unclose all shells having free edges
513   for (TopTools_DataMapIteratorOfDataMapOfShapeShape it(M); it.More(); it.Next()) {
514     TopoDS_Shape S = it.Value();
515     S.Closed(Standard_Boolean(Standard_False));
516   }
517   
518   TopTools_MapIteratorOfMapOfShape itother(MapOtherShape); //gka version for free edges
519   for( ; itother.More() ; itother.Next()) {
520     if(!EdgesFaces.Contains(itother.Key()) && myBounds.Contains(itother.Key())) {
521       TopoDS_Shape aSh = myBounds.FindFromKey(itother.Key());
522       B.Add(result,aSh);
523     }
524   }
525   return result;
526 }
527