0023024: Update headers of OCCT files
[occt.git] / src / BOPTest / BOPTest_TolerCommands.cxx
1 // Created on: 2000-03-16
2 // Created by: Peter KURNEV
3 // Copyright (c) 2000-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
22 #include <BOPTest.ixx>
23 #include <stdio.h>
24 #include <TCollection_AsciiString.hxx>
25 #include <TColStd_IndexedMapOfTransient.hxx>
26 #include <TopoDS_Shape.hxx>
27 #include <TopoDS_Vertex.hxx>
28 #include <DBRep.hxx>
29 #include <gp_Pnt2d.hxx>
30
31 #include <Geom_Curve.hxx>
32 #include <Geom2d_Curve.hxx>
33 #include <Geom_Surface.hxx>
34
35 #include <TopoDS.hxx>
36 #include <TopoDS_Vertex.hxx>
37 #include <TopoDS_Edge.hxx>
38 #include <TopoDS_Face.hxx>
39
40 #include <TopAbs_Orientation.hxx>
41
42 #include <TopTools_ListIteratorOfListOfShape.hxx>
43 #include <TopTools_ListOfShape.hxx>
44 #include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
45 #include <TopTools_MapOfShape.hxx>
46 #include <TopTools_IndexedMapOfShape.hxx>
47
48 #include <BRep_TVertex.hxx>
49 #include <BRep_TEdge.hxx>
50 #include <BRep_ListOfCurveRepresentation.hxx>
51 #include <BRep_ListIteratorOfListOfCurveRepresentation.hxx>
52 #include <BRep_CurveRepresentation.hxx>
53 #include <BRep_Tool.hxx>
54 #include <BRep_Builder.hxx>
55 #include <BRep_TFace.hxx>
56
57 #include <TopLoc_Location.hxx>
58
59 #include <BRepLib.hxx>
60
61 #include <TopExp.hxx>
62 #include <TopExp_Explorer.hxx>
63
64 static 
65   Standard_Integer breducetolerance (Draw_Interpretor&, Standard_Integer, const char** );
66 static 
67   Standard_Integer  btolx           (Draw_Interpretor&, Standard_Integer, const char** );
68 static
69   Standard_Integer  bopaddpcs       (Draw_Interpretor&, Standard_Integer, const char** );
70 //
71 static 
72   void ProcessVertex(const TopoDS_Vertex&,
73                      const TopTools_ListOfShape&,
74                      const TopTools_ListOfShape&);
75 static
76   void ProcessEdge(const TopoDS_Edge&, const Standard_Real);
77
78 static
79   void ReduceVertexTolerance (const TopoDS_Shape&);
80
81 static 
82   void ReduceFaceTolerance (const TopoDS_Shape&);
83
84 static
85   void ReduceEdgeTolerance (const TopoDS_Shape&, const Standard_Real);
86
87
88 //=======================================================================
89 //function : TolerCommands
90 //purpose  : 
91 //=======================================================================
92   void  BOPTest::TolerCommands(Draw_Interpretor& theCommands)
93 {
94   static Standard_Boolean done = Standard_False;
95   if (done) 
96     return;
97
98   done = Standard_True;
99   // Chapter's name
100   const char* g = "CCR commands";
101   //
102   theCommands.Add("breducetolerance" ,  "Use >breducetolerance Shape [maxTol=0.01]",  __FILE__, breducetolerance, g);
103   theCommands.Add("btolx"     ,  "Use >btolx Shape [minTol=1.e-7]",  __FILE__, btolx, g);
104   theCommands.Add("bopaddpcs" ,  "Use >bopaddpcs Shape"           ,  __FILE__, bopaddpcs, g);
105 }
106
107 //=======================================================================
108 //function : btolx
109 //purpose  : 
110 //=======================================================================
111 Standard_Integer  btolx(Draw_Interpretor& di, Standard_Integer n,  const char** a)
112 {
113   if (n<2) {
114     di << " Use >btolx Shape [minTol=1.e-7]\n";
115     return 1;
116   }
117
118   TopoDS_Shape aS = DBRep::Get(a[1]);
119   
120   if (aS.IsNull()) {
121     di << " Null shape is not allowed \n";
122     return 1;
123   }
124   //
125   Standard_Real aTolEMin=1.e-7;
126   if (n==3) {
127     aTolEMin=atof(a[2]);
128   }
129   //
130   // Edge Tolerances
131   ReduceEdgeTolerance(aS, aTolEMin);
132   //
133   // Face Tolerances
134   ReduceFaceTolerance(aS);
135   //
136   // Vertex Tolerances
137   ReduceVertexTolerance(aS);
138   //
139   BRepLib::SameParameter(aS, 1.e-7, Standard_True);
140   //
141   DBRep::Set (a[1], aS);
142   return 0;
143 }
144 //=======================================================================
145 //function : ReduceEdgeTolerance
146 //purpose  : 
147 //=======================================================================
148 void ReduceEdgeTolerance (const TopoDS_Shape& aS, const Standard_Real aTolTreshold)
149 {
150   Standard_Integer i, aNbE;
151   TopTools_IndexedMapOfShape aEMap;
152   //
153   TopExp::MapShapes(aS, TopAbs_EDGE, aEMap);
154   //
155   aNbE=aEMap.Extent();
156   for (i=1; i<=aNbE; i++) {
157     const TopoDS_Edge& aE= TopoDS::Edge(aEMap(i));
158
159     ProcessEdge(aE, aTolTreshold);
160   } 
161 }
162 //=======================================================================
163 //function : ReduceFaceTolerance
164 //purpose  : 
165 //=======================================================================
166 void ReduceFaceTolerance (const TopoDS_Shape& aS)
167 {
168   Standard_Integer i, j, aNbF, aNbE;
169   Standard_Real aTolE, aTolx, aTolEMin;
170   TopTools_IndexedMapOfShape aFMap, aEMap;
171   //
172   aTolEMin=1.e-7;
173   //
174   TopExp::MapShapes(aS, TopAbs_FACE, aFMap);
175   aNbF=aFMap.Extent();
176   for (i=1; i<=aNbF; i++) {
177     aTolx=1.e6;
178     const TopoDS_Face& aF= TopoDS::Face(aFMap(i));
179     Handle(BRep_TFace)& aTF = *((Handle(BRep_TFace)*)&aF.TShape());
180     //
181     TopExp::MapShapes(aF, TopAbs_EDGE, aEMap);
182     aNbE=aEMap.Extent();
183     for (j=1; j<=aNbE; ++j) {
184       const TopoDS_Edge& aE= TopoDS::Edge(aEMap(j));
185       aTolE =BRep_Tool::Tolerance(aE);
186       if (aTolE<aTolx) {
187         aTolx=aTolE;
188       }
189     }
190     aTolE=(aTolx>aTolEMin) ? aTolx : aTolEMin;
191     aTF->Tolerance(aTolE);
192   }
193 }
194 //=======================================================================
195 //function : ReduceVertexTolerance
196 //purpose  : 
197 //=======================================================================
198 void ReduceVertexTolerance (const TopoDS_Shape& aS)
199 {
200   Standard_Integer i, aNbV;
201   TopTools_IndexedDataMapOfShapeListOfShape aVEMap, aVFMap;
202
203   TopExp::MapShapesAndAncestors(aS, TopAbs_VERTEX, TopAbs_EDGE, aVEMap);
204   TopExp::MapShapesAndAncestors(aS, TopAbs_VERTEX, TopAbs_FACE, aVFMap);
205
206   aNbV=aVEMap.Extent();
207   for (i=1; i<=aNbV; i++) {
208     const TopoDS_Vertex& aV= TopoDS::Vertex(aVEMap.FindKey(i));
209     const TopTools_ListOfShape& aLE=aVEMap(i);
210     const TopTools_ListOfShape& aLF=aVFMap.FindFromKey(aV);
211     
212     ProcessVertex(aV, aLE, aLF);
213   }
214 }
215 //=======================================================================
216 //function : ProcessEdge
217 //purpose  : 
218 //=======================================================================
219 void ProcessEdge(const TopoDS_Edge& aE, const Standard_Real aTolTreshold)
220 {
221   Standard_Integer i, aNb=23;
222   Standard_Real aTolE, aD2, aTolMax2, aT1, aT2, aT, dT;
223   gp_Pnt aPC3D, aP3D;
224   gp_Pnt2d aPC2D;
225
226   //TopTools_ListIteratorOfListOfShape anIt;// Wng in Gcc 3.0
227   BRep_ListIteratorOfListOfCurveRepresentation itcr;
228   //
229   Handle(Geom_Curve) aC3D=BRep_Tool::Curve(aE, aT1, aT2);
230   if (aC3D.IsNull()) {
231     return;
232   }
233   //
234   dT=(aT2-aT1)/aNb;
235   //
236   Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*)&aE.TShape());
237   const TopLoc_Location& Eloc = aE.Location();
238   //
239   aTolMax2=-1.e6;
240   const BRep_ListOfCurveRepresentation& aLCR=TE->Curves();
241   //
242   itcr.Initialize(aLCR);
243   for (; itcr.More(); itcr.Next()) {
244     const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
245     const TopLoc_Location& loc = cr->Location();
246     TopLoc_Location L = (Eloc * loc);//.Predivided(aV.Location());
247     //
248     // 3D-Curve
249     if (cr->IsCurve3D()) {
250       continue;
251     }
252     //
253     // 2D-Curve
254     else if (cr->IsCurveOnSurface()) {
255       const Handle(Geom2d_Curve)& aC2D = cr->PCurve();
256       if (aC2D.IsNull()) {
257         continue;
258       }
259       // Surface
260       const Handle(Geom_Surface)& aS=cr->Surface();
261       //
262       // 2D-point treatment
263       for (i=0; i<=aNb; ++i) {
264         aT=aT1+i*dT;
265         if (i==aNb) {
266           aT=aT2;
267         }
268         aPC3D=aC3D->Value(aT);
269         aPC2D=aC2D->Value(aT);
270         aS->D0(aPC2D.X(), aPC2D.Y(), aP3D);
271         aP3D.Transform(L.Transformation());
272         aD2=aPC3D.SquareDistance(aP3D);
273         if (aD2 > aTolMax2) {
274           aTolMax2=aD2;
275         }
276       }
277     } //if (cr->IsCurveOnSurface())
278   }//for (; itcr.More(); itcr.Next())
279
280   //#########################################################
281   //
282   if (aTolMax2<0.){
283     return;
284   }
285   //
286   aTolE =BRep_Tool::Tolerance(aE);
287   //
288   aTolMax2=sqrt(aTolMax2); 
289   
290   //printf(" aTolMax=%15.10lf, aTolWas=%15.10lf\n", aTolMax2, aTolE);
291
292   Standard_Real aTolSet;
293   aTolSet=(aTolMax2>aTolTreshold) ? aTolMax2 : aTolTreshold;
294
295   TE->Tolerance(aTolSet);
296 }
297 //=======================================================================
298 //function : ProcessVertex
299 //purpose  : 
300 //=======================================================================
301 void ProcessVertex(const TopoDS_Vertex& aV,
302                    const TopTools_ListOfShape& aLE,
303                    const TopTools_ListOfShape& aLF)
304 {
305   Standard_Real aTol, aTol2, aD2, aTolMax2, aTolE, aParam;
306   gp_Pnt aPC3D;
307   gp_Pnt2d aPC2D;
308   TopAbs_Orientation anOrV;
309
310   TopTools_ListIteratorOfListOfShape anIt;
311   TopTools_MapOfShape aProcessedEdges;
312   TopExp_Explorer aVExp;
313   
314   BRep_ListIteratorOfListOfCurveRepresentation itcr;
315   //
316   aTolMax2=-1.e6;
317   //
318   Handle(BRep_TVertex)& TV = *((Handle(BRep_TVertex)*) &aV.TShape());
319   const gp_Pnt& aPV3D = TV->Pnt();
320   aTol =BRep_Tool::Tolerance(aV);
321   aTol2=aTol*aTol;
322   //
323   anIt.Initialize(aLE);
324   for (; anIt.More(); anIt.Next()) {
325     const TopoDS_Edge& aE=TopoDS::Edge(anIt.Value());
326     //
327     if (aProcessedEdges.Contains(aE)) {
328       continue;
329     }
330     aProcessedEdges.Add(aE);                           
331     //
332     Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*)&aE.TShape());
333     const TopLoc_Location& Eloc = aE.Location();
334     //
335     aVExp.Init(aE, TopAbs_VERTEX);
336     for (; aVExp.More(); aVExp.Next()) {
337       const TopoDS_Vertex& aVx=TopoDS::Vertex(aVExp.Current());
338       //
339       if (!aVx.IsSame(aV)) {
340         continue;
341       }
342       //
343       anOrV=aVx.Orientation();
344       if (!(anOrV==TopAbs_FORWARD || anOrV==TopAbs_REVERSED)) {
345         continue;
346       }
347       //
348       const BRep_ListOfCurveRepresentation& aLCR=TE->Curves();
349       itcr.Initialize(aLCR);
350       for (; itcr.More(); itcr.Next()) {
351         const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
352         const TopLoc_Location& loc = cr->Location();
353         TopLoc_Location L = (Eloc * loc).Predivided(aV.Location());
354         //
355         // 3D-Curve
356         if (cr->IsCurve3D()) {
357           const Handle(Geom_Curve)& aC3D = cr->Curve3D();
358           //
359           if (aC3D.IsNull()) {
360             continue;
361           }
362           // 3D-point treatment
363           aParam=BRep_Tool::Parameter(aVx, aE);
364           aPC3D= aC3D->Value(aParam);
365           aPC3D.Transform(L.Transformation());
366           aD2=aPV3D.SquareDistance(aPC3D);
367           if (aD2 > aTolMax2) {
368             aTolMax2=aD2;
369           }
370           //
371         }//if (cr->IsCurve3D())
372         //
373         // 2D-Curve
374         else if (cr->IsCurveOnSurface()) {
375           const Handle(Geom2d_Curve)& aC2D = cr->PCurve();
376           if (aC2D.IsNull()) {
377             continue;
378           }
379           // Surface
380           const Handle(Geom_Surface)& aS=cr->Surface();
381           //
382           // 2D-point treatment
383           aParam=BRep_Tool::Parameter(aVx, aE, aS, L);
384           aPC2D=aC2D->Value(aParam);
385           aS->D0(aPC2D.X(), aPC2D.Y(), aPC3D);
386           aPC3D.Transform(L.Transformation());
387           aD2=aPV3D.SquareDistance(aPC3D);
388           if (aD2 > aTolMax2) {
389             aTolMax2=aD2;
390           }
391         } //if (cr->IsCurveOnSurface())
392
393       }//for (; itcr.More(); itcr.Next())
394     }//for (; aVExp.More(); aVExp.Next()) 
395   }//for (; anIt.More(); anIt.Next()) 
396   //#########################################################
397   //
398   // Reducing
399   if (aTolMax2<0.){
400     return;
401   }
402   //
403   aTolMax2=sqrt(aTolMax2); 
404   if (aTolMax2>aTol) {
405     return;
406   }
407   //
408   aProcessedEdges.Clear();
409   anIt.Initialize(aLE);
410   for (; anIt.More(); anIt.Next()) {
411     const TopoDS_Edge& aE=TopoDS::Edge(anIt.Value());
412
413     if (aProcessedEdges.Contains(aE)) {
414       continue;
415     }
416     aProcessedEdges.Add(aE);
417
418     aTolE =BRep_Tool::Tolerance(aE);
419     if (aTolMax2 < aTolE) {
420       aTolMax2=aTolE;
421     }
422   }
423   //
424   aProcessedEdges.Clear();
425   anIt.Initialize(aLF);
426   for (; anIt.More(); anIt.Next()) {
427     const TopoDS_Face& aF=TopoDS::Face(anIt.Value());
428     
429     if (aProcessedEdges.Contains(aF)) {
430       continue;
431     }
432     aProcessedEdges.Add(aF);
433     
434     aTolE =BRep_Tool::Tolerance(aF);
435     if (aTolMax2 < aTolE) {
436       aTolMax2=aTolE;
437     }
438   }
439   //
440   if (aTolMax2>aTol) {
441     return;
442   }
443   //
444   // Update Tolerance
445   TV->Tolerance(aTolMax2);
446 }
447 //=======================================================================
448 //function : breducetolerance
449 //purpose  : 
450 //=======================================================================
451 Standard_Integer  breducetolerance(Draw_Interpretor& di, 
452                                    Standard_Integer n, 
453                                    const char** a)
454 {
455   if (n<2) {
456     di << " Use >bupdatetolerance Shape\n";
457     return 1;
458   }
459
460   TopoDS_Shape aS = DBRep::Get(a[1]);
461   
462   if (aS.IsNull()) {
463     di << " Null shape is not allowed \n";
464     return 1;
465   }
466   ReduceVertexTolerance(aS);
467   DBRep::Set (a[1], aS);
468   
469   return 0;
470 }
471 //
472 //
473 static
474   void PreparePCurves(const TopoDS_Shape& aShape, Draw_Interpretor& di);
475
476 //=======================================================================
477 //function : bopaddpcs
478 //purpose  : Some Edgesdo not contain P-Curveson Faces to which they belong to. 
479 //           These faces usually based on Geom_Plane surface.
480 //           To prevent sophisticated treatment the Command "bopaddpcs:
481 //           adds P-Curves for the edges . 
482 //=======================================================================
483 Standard_Integer  bopaddpcs(Draw_Interpretor& di, Standard_Integer n,  const char** a)
484 {
485   if (n<2) {
486     di << " Use >bopaddpcs Shape\n";
487     return 1;
488   }
489
490   TopoDS_Shape aS = DBRep::Get(a[1]);
491   
492   if (aS.IsNull()) {
493     di << " Null shape is not allowed \n";
494     return 1;
495   }
496   //
497   PreparePCurves(aS, di);
498   //
499   DBRep::Set (a[1], aS);
500   return 0;
501 }
502
503 //=======================================================================
504 //function : PreparePCurves
505 //purpose  : 
506 //=======================================================================
507 void PreparePCurves(const TopoDS_Shape& aShape, Draw_Interpretor& di)
508 {
509   Standard_Integer i, aNbE;
510   Standard_Real aTolE, aT1, aT2;
511   TopTools_IndexedDataMapOfShapeListOfShape aEFMap;
512   TopLoc_Location aLoc;
513   Handle(Geom_Curve)   aC3D;
514   Handle(Geom2d_Curve) aC2D;
515   BRep_Builder aBB;
516   //
517   TopExp::MapShapesAndAncestors (aShape, TopAbs_EDGE, TopAbs_FACE, aEFMap);
518   //
519   aNbE=aEFMap.Extent();
520   for (i=1; i<=aNbE; ++i) {
521     const TopoDS_Edge& aE=TopoDS::Edge(aEFMap.FindKey(i));
522     //
523     if (BRep_Tool::Degenerated(aE)) {
524       continue;
525     }
526     //
527     aC3D=BRep_Tool::Curve(aE, aT1, aT2);
528     if (aC3D.IsNull()) {
529       continue;
530     }
531     aTolE=BRep_Tool::Tolerance(aE);
532     //
533     const TopTools_ListOfShape& aLF=aEFMap(i);
534     TopTools_ListIteratorOfListOfShape aFIt(aLF);
535     for (; aFIt.More(); aFIt.Next()) {
536       const TopoDS_Face& aF=TopoDS::Face(aFIt.Value());
537       //
538       // Map of surfaces on which the edge lays .
539       TColStd_IndexedMapOfTransient aSCRMap;
540       Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*)&aE.TShape());
541       const BRep_ListOfCurveRepresentation& aLCR=TE->Curves();
542       BRep_ListIteratorOfListOfCurveRepresentation itcr;
543       itcr.Initialize(aLCR);
544       for (; itcr.More(); itcr.Next()) {
545         const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
546         //
547         if (cr->IsCurveOnSurface()) {
548           const Handle(Geom_Surface)& aSCR=cr->Surface();
549           aSCRMap.Add(aSCR);
550         }
551         //
552       }
553       //
554       const Handle(Geom_Surface)& aS=BRep_Tool::Surface(aF, aLoc);
555       if (!aSCRMap.Contains(aS)) {
556         // try to obtain 2D curve
557         aC2D=BRep_Tool::CurveOnSurface(aE, aS, aLoc, aT1, aT2);
558         if (aC2D.IsNull()) {
559           di << " Warning: Can not obtain P-Curve\n";
560           continue;
561         }
562         else {
563           aBB.UpdateEdge(aE, aC2D, aF, aTolE);
564         }
565       }
566     }
567   }
568 }