0031340: LDOM fails to read XML file starting with BOM
[occt.git] / src / QABugs / QABugs_14.cxx
1 // Created on: 2002-03-19
2 // Created by: QA Admin
3 // Copyright (c) 2002-2014 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and/or modify it under
8 // the terms of the GNU Lesser General Public License version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16 #include <stdio.h>
17
18 #include <QABugs.hxx>
19
20 #include <Draw_Interpretor.hxx>
21 #include <DBRep.hxx>
22 #include <DrawTrSurf.hxx>
23 #include <AIS_InteractiveContext.hxx>
24 #include <ViewerTest.hxx>
25 #include <AIS_Shape.hxx>
26 #include <TopoDS_Shape.hxx>
27
28 #include <Geom2d_Line.hxx>
29 #include <TColgp_Array1OfPnt2d.hxx>
30 #include <Geom2d_BezierCurve.hxx>
31 #include <Geom2dAdaptor_Curve.hxx>
32 #include <Geom2dGcc_QualifiedCurve.hxx>
33 #include <Geom2dGcc_Circ2d2TanRad.hxx>
34 #include <Geom2d_Circle.hxx>
35 #include <TopoDS_Edge.hxx>
36 #include <TopoDS.hxx>
37 #include <BRepAdaptor_Curve.hxx>
38 #include <gp_Lin.hxx>
39 #include <BRepFeat_SplitShape.hxx>
40 #include <DBRep_DrawableShape.hxx>
41 #include <BRep_Builder.hxx>
42 #include <TopTools_ListIteratorOfListOfShape.hxx>
43 #include <BRepExtrema_DistShapeShape.hxx>
44 #include <Draw.hxx>
45 #include <TopoDS_Vertex.hxx>
46 #include <BRepLib_MakeVertex.hxx>
47 #include <BRepLib_MakeEdge.hxx>
48 #include <TColgp_HArray1OfPnt.hxx>
49 #include <GeomAPI_Interpolate.hxx>
50 #include <Precision.hxx>
51 #include <Geom_BSplineCurve.hxx>
52 #include <OSD_Path.hxx>
53 #include <ShapeBuild_ReShape.hxx>
54 #include <ShapeExtend_WireData.hxx>
55 #include <TopoDS_Wire.hxx>
56 #include <ShapeExtend_WireData.hxx>
57 #include <ShapeFix_Wire.hxx>
58 #include <ShapeAnalysis_WireOrder.hxx>
59 #include <ShapeAnalysis_Wire.hxx>
60 #include <TopExp.hxx>
61 #include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
62 #include <BRep_Tool.hxx>
63 #include <ShapeAnalysis_Curve.hxx>
64 #include <V3d_View.hxx>
65 #include <Standard_ErrorHandler.hxx>
66
67 static Standard_Integer BUC60897 (Draw_Interpretor& di, Standard_Integer /*argc*/, const char ** /*argv*/)
68 {
69   Standard_Character abuf[16];
70
71   Handle(Geom2d_Line) aLine = new Geom2d_Line(gp_Pnt2d(100, 0), gp_Dir2d(-1, 0));
72   Sprintf(abuf,"line");
73   Standard_CString st = abuf;
74   DrawTrSurf::Set (st, aLine);
75
76   TColgp_Array1OfPnt2d aPoints(1, 3);
77   aPoints.SetValue(1, gp_Pnt2d(0, 0));
78   aPoints.SetValue(2, gp_Pnt2d(50, 50));
79   aPoints.SetValue(3, gp_Pnt2d(0, 100));
80   Handle(Geom2d_BezierCurve) aCurve = new Geom2d_BezierCurve(aPoints);
81   Sprintf(abuf,"curve");
82   DrawTrSurf::Set (st, aCurve);
83
84   Geom2dAdaptor_Curve aCLine(aLine);
85   Geom2dAdaptor_Curve aCCurve(aCurve);
86   Geom2dGcc_QualifiedCurve aQualifCurve1(aCLine, GccEnt_outside);
87   Geom2dGcc_QualifiedCurve aQualifCurve2(aCCurve, GccEnt_outside);
88   Geom2dGcc_Circ2d2TanRad aGccCirc2d(aQualifCurve1, aQualifCurve2, 10, 1e-7);
89   if(!aGccCirc2d.IsDone())
90   {
91     di << "Faulty: can not create a circle.\n";
92     return 1;
93   }
94   for(Standard_Integer i = 1; i <= aGccCirc2d.NbSolutions(); i++)
95   {
96     gp_Circ2d aCirc2d = aGccCirc2d.ThisSolution(i);
97     di << "circle : X " << aCirc2d.Location().X() << " Y " << aCirc2d.Location().Y() << " R " << aCirc2d.Radius();
98     Standard_Real aTmpR1, aTmpR2;
99     gp_Pnt2d aPnt2d1, aPnt2d2;
100     aGccCirc2d.Tangency1(i, aTmpR1, aTmpR2, aPnt2d1);
101     aGccCirc2d.Tangency2(i, aTmpR1, aTmpR2, aPnt2d2);
102     di << "\ntangency1 : X " << aPnt2d1.X() << " Y " << aPnt2d1.Y();
103     di << "\ntangency2 : X " << aPnt2d2.X() << " Y " << aPnt2d2.Y() << "\n";
104     
105     Sprintf(abuf,"circle_%d",i);
106     Handle(Geom2d_Curve) circ_res = new Geom2d_Circle(aCirc2d);
107     DrawTrSurf::Set (st, circ_res);
108   }
109
110   di << "done\n";
111   return 0;
112 }
113
114 static Standard_Integer BUC60889 (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
115 {
116   if(argc != 10) {
117     di << "Usage : " << argv[0] << " point_1 point_2 name_of_edge bndbox_X1 bndbox_Y1 bndbox_Z1 bndbox_X2 bndbox_Y2 bndbox_Z2\n";
118     return 1;
119   } else {
120     gp_Pnt p1, p2;
121     if (!(DrawTrSurf::GetPoint(argv[1], p1)) || !(DrawTrSurf::GetPoint(argv[2], p2)))
122     {
123       di << "Need two points to define a band\n";
124       return 1;
125     }
126     TopoDS_Edge ed = TopoDS::Edge(DBRep::Get(argv[3]));
127     if (ed.IsNull())
128     {
129       di << "Need an edge to define the band direction\n";
130       return 1;
131     }
132     BRepAdaptor_Curve curve(ed);
133     gp_Dir d = curve.Line().Direction();
134     Bnd_Box bnd_box;
135     bnd_box.Update(Draw::Atof(argv[4]), Draw::Atof(argv[5]), Draw::Atof(argv[6]), Draw::Atof(argv[7]), Draw::Atof(argv[8]), Draw::Atof(argv[9]));
136     if(bnd_box.IsOut(p1, p2, d))
137       di << "The band lies out of the box\n";
138     else
139       di << "The band intersects the box\n";
140     
141     return 0;
142   }
143 }
144
145 static Standard_Integer BUC60852 (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
146 {
147   if(argc != 8)
148     di << "Usage : " << argv[0] << " name_of_edge bndbox_X1 bndbox_Y1 bndbox_Z1 bndbox_X2 bndbox_Y2 bndbox_Z2\n";
149   else {
150     TopoDS_Edge shape = TopoDS::Edge(DBRep::Get(argv[1]));
151     if(shape.ShapeType() != TopAbs_EDGE)
152       di << "shape must be an edge\n";
153     else {
154       BRepAdaptor_Curve curve(shape);
155       gp_Lin lin = curve.Line();
156       Bnd_Box bnd_box;
157       bnd_box.Update(Draw::Atof(argv[2]), Draw::Atof(argv[3]), Draw::Atof(argv[4]), Draw::Atof(argv[5]), Draw::Atof(argv[6]), Draw::Atof(argv[7]));
158       if(bnd_box.IsOut(lin))
159         di << "Line that lies on edge does not intersect the box\n";
160       else
161         di << "Line that lies on edge intersects the box\n";
162     }
163   }
164   return 0;
165 }
166
167 static Standard_Integer BUC60854 (Draw_Interpretor& /*di*/, Standard_Integer argc, const char ** argv)
168 {
169   Standard_Integer newnarg;
170   if (argc < 3) return 1;
171   TopoDS_Shape S = DBRep::Get(argv[2]);
172   BRepFeat_SplitShape Spls(S);
173   Standard_Boolean pick = Standard_False;
174   TopoDS_Shape EF;
175   Standard_Real u,v;
176   Standard_Integer i = 3;
177   for ( newnarg=3; newnarg<argc; newnarg++) {
178     if (argv[newnarg][0] == '@') {
179       break;
180     }
181   }
182   if (newnarg == 3 || 
183       (newnarg !=argc && ((argc-newnarg)<=2 || (argc-newnarg)%2 != 1))) {
184     return 1;
185   }
186   if (i<newnarg) {
187     pick = (argv[i][0] == '.');
188     EF = DBRep::Get(argv[i],TopAbs_FACE);
189     if (EF.IsNull()) return 1;
190   }
191   while (i < newnarg) {
192     if (pick) {
193       DBRep_DrawableShape::LastPick(EF,u,v);
194     }
195     if (EF.ShapeType() == TopAbs_FACE) {
196       i++;
197       while (i < newnarg) {
198         TopoDS_Shape W;
199         Standard_Boolean rever = Standard_False;
200         if (argv[i][0] == '-') {
201           if (argv[i][1] == '\0')
202             return 1;
203           pick = (argv[i][1] == '.');
204           const char* Temp = argv[i]+1;
205           W = DBRep::Get(Temp,TopAbs_SHAPE,Standard_False);
206           rever = Standard_True;
207         }
208         else {
209           pick = (argv[i][0] == '.');
210           W = DBRep::Get(argv[i],TopAbs_SHAPE,Standard_False);
211         }
212         if (W.IsNull()) {
213           return 1;
214         }
215         TopAbs_ShapeEnum wtyp = W.ShapeType();
216         if (wtyp != TopAbs_WIRE && wtyp != TopAbs_EDGE && pick) {
217           Standard_Real aTempU, aTempV;
218           DBRep_DrawableShape::LastPick(W, aTempU, aTempV);
219           wtyp = W.ShapeType();
220         }
221         if (wtyp != TopAbs_WIRE && wtyp != TopAbs_EDGE) {
222           EF = DBRep::Get(argv[i]);
223           break;
224         }
225         else {
226           if (rever) {
227             W.Reverse();
228           }
229           if (wtyp == TopAbs_WIRE) {
230             Spls.Add(TopoDS::Wire(W),TopoDS::Face(EF));
231           }
232           else {
233             Spls.Add(TopoDS::Edge(W),TopoDS::Face(EF));
234           }
235         }
236         i++;
237       }
238     }
239     else
240       return 1;
241   }
242   i++;
243   while (argv[i][0] != '#') {
244     TopoDS_Shape Ew,Es;
245     TopoDS_Shape aLocalShape(DBRep::Get(argv[i],TopAbs_EDGE));
246     Es = TopoDS::Edge(aLocalShape);
247     if (Es.IsNull()) {
248       return 1;
249     }
250     aLocalShape = DBRep::Get(argv[i+1],TopAbs_EDGE);
251     Ew = TopoDS::Edge(aLocalShape);
252     if (Ew.IsNull()) {
253       return 1;
254     }
255     Spls.Add(TopoDS::Edge(Ew),TopoDS::Edge(Es));
256     i += 2;
257   }
258   Spls.Build();
259   const TopTools_ListOfShape& aLeftPart = Spls.Left();
260   const TopTools_ListOfShape& aRightPart = Spls.Right();
261   BRep_Builder BB;
262   TopoDS_Shape aShell;
263   BB.MakeShell(TopoDS::Shell(aShell));
264   TopTools_ListIteratorOfListOfShape anIter;
265   if (argv[argc - 1][0] == 'L') {
266     anIter.Initialize(aLeftPart);
267   } 
268   else if (argv[argc - 1][0] == 'R') {
269     anIter.Initialize(aRightPart);
270   }
271   else {
272     return 1;
273   }
274   for(; anIter.More(); anIter.Next()) BB.Add(aShell, anIter.Value());
275   aShell.Closed (BRep_Tool::IsClosed (aShell));
276   DBRep::Set(argv[1],aShell);
277   return 0;
278 }
279
280 static Standard_Integer BUC60870 (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
281 {
282   Standard_Integer i1;
283   if (argc != 5) {
284     di << "Usage : " << argv[0] << " result name_of_shape_1 name_of_shape_2 dev\n";
285     return 1;
286   }
287   const char *ns1 = (argv[2]), *ns2 = (argv[3]), *ns0 = (argv[1]);
288   TopoDS_Shape S1(DBRep::Get(ns1)), S2(DBRep::Get(ns2))  ;
289   Standard_Real dev =  Draw::Atof(argv[4]);
290   BRepExtrema_DistShapeShape dst(S1 ,S2, dev );
291   if (dst.IsDone()) {
292     char named[100];
293     Sprintf(named, "%s%s" ,ns0,"_val");
294     char* tempd = named;
295     Draw::Set(tempd,dst.Value());
296     di << named << " ";
297     for (i1=1; i1<= dst.NbSolution(); i1++) {
298       gp_Pnt P1,P2;
299       P1 = (dst.PointOnShape1(i1));
300       P2 = (dst.PointOnShape2(i1));
301       if (dst.Value()<=1.e-9) {
302         TopoDS_Vertex V =BRepLib_MakeVertex(P1);
303         char namev[100];
304         if (i1==1) {
305           Sprintf(namev, "%s" ,ns0);
306         } else {
307           Sprintf(namev, "%s%d" ,ns0,i1);
308         }
309         char* tempv = namev;
310         DBRep::Set(tempv,V);
311         di << namev << " ";
312       } else {
313         char name[100];
314         TopoDS_Edge E = BRepLib_MakeEdge (P1, P2);
315         if (i1==1) {
316           Sprintf(name,"%s",ns0);
317         } else {
318           Sprintf(name,"%s%d",ns0,i1);
319         }
320         char* temp = name;
321         DBRep::Set(temp,E);
322         di << name << " " ;
323       }
324     }
325   } else {
326     di << "Faulty : found a problem\n";
327   }
328   return 0;
329 }
330
331 static Standard_Integer BUC60902 (Draw_Interpretor& di, Standard_Integer /*argc*/, const char ** /*argv*/)
332 {
333   Handle(TColgp_HArray1OfPnt) aPnts = new TColgp_HArray1OfPnt(1,5);
334   gp_Pnt aP(0., 0., 0.);
335   for(Standard_Integer i = 1; i <= 5; i++) {
336     aP.SetX((i-1)*1.57);
337     aP.SetY(Sin((i-1)*1.57));
338     aPnts->SetValue(i, aP);
339   }
340   GeomAPI_Interpolate anInterpolater(aPnts, Standard_False, Precision::Confusion());
341   anInterpolater.Perform(); 
342   if(!anInterpolater.IsDone()) {
343     di << "Faulty : error in interpolation\n";
344     return 1;
345   }
346   Handle(Geom_BSplineCurve) aCur = anInterpolater.Curve(); 
347   gp_Vec aFirstTang, aLastTang;
348   aCur->D1(aCur->FirstParameter(), aP, aFirstTang);
349   aCur->D1(aCur->LastParameter(), aP, aLastTang);
350   di << " Used Tang1 = " << aFirstTang.X() << " " << aFirstTang.Y() << " " << aFirstTang.Z() << "\n"; 
351   di << " Used Tang2 = " << aLastTang.X() << " " << aLastTang.Y() << " " << aLastTang.Z() << "\n"; 
352   GeomAPI_Interpolate anInterpolater1(aPnts, Standard_False, Precision::Confusion());
353   anInterpolater1.Load(aFirstTang, aLastTang, Standard_False); 
354   anInterpolater1.Perform(); 
355   if(!anInterpolater1.IsDone()) {
356     di << "Faulty : error in interpolation 1\n";
357     return 1;
358   }
359   aCur = anInterpolater1.Curve();
360   gp_Vec aFirstTang1, aLastTang1;
361   aCur->D1(aCur->FirstParameter(), aP, aFirstTang1);
362   aCur->D1(aCur->LastParameter(), aP, aLastTang1);
363   di << " Tang1 after compute = " << aFirstTang1.X() << " " << aFirstTang1.Y() << " " << aFirstTang1.Z() << "\n"; 
364   di << " Tang2 after compute = " << aLastTang1.X() << " " << aLastTang1.Y() << " " << aLastTang1.Z() << "\n"; 
365   if(aFirstTang.IsEqual(aFirstTang1, Precision::Confusion(), Precision::Angular())) {
366     di << "First tangent is OK\n";
367   }
368   else {
369     di << "Faulty : first tangent is wrong\n";
370   }
371   if(aLastTang.IsEqual(aLastTang1, Precision::Confusion(), Precision::Angular())) {
372     di << "Last tangent is OK\n";
373   }
374   else {
375     di << "Faulty : last tangent is wrong\n";
376   }
377   return 0;
378 }
379
380 static Standard_Integer BUC60944 (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
381 {
382   if(argc != 2) {
383     di << "Usage : " << argv[0] << " path\n";
384   }
385
386   TCollection_AsciiString in(argv[1]);
387   OSD_Path* aPath = new OSD_Path(in);
388   TCollection_AsciiString out;
389   aPath->SystemName(out);
390   if(in == out) 
391     di << "The convertion is right.\n";
392   else
393     di << "Faulty : The convertion is incorrect : " << out.ToCString() << "\n";
394   di << out.ToCString() << "\n";
395 //  std::cout << aPath->Trek() << " !" << std::endl;
396   return 0;
397 }
398
399 Standard_Boolean BuildWiresWithReshape
400                 (const Handle(ShapeBuild_ReShape)& theReshape,
401                  const TopTools_ListOfShape &theListOfEdges,
402                  TopTools_ListOfShape       &theListOfWires,
403                  const Standard_Boolean      isFixConnectedMode,
404                  const Standard_Boolean      isKeepLoopsMode,
405                  const Standard_Real         theTolerance)
406 {
407   TopTools_ListIteratorOfListOfShape anEdgeIter;
408   Standard_Boolean                   isDone;
409   TopoDS_Wire                        aWire;
410
411   theListOfWires.Clear();
412   Handle(ShapeExtend_WireData) aWireData  = new ShapeExtend_WireData;
413   Handle(ShapeFix_Wire) aShFixWire = new ShapeFix_Wire;
414   aShFixWire->SetContext (theReshape);
415
416   Handle(ShapeAnalysis_Wire) aWireAnalyzer;
417   ShapeAnalysis_WireOrder aWireOrder;
418
419   aShFixWire->Load(aWireData);
420   aShFixWire->SetPrecision(theTolerance);
421
422   for(anEdgeIter.Initialize(theListOfEdges); anEdgeIter.More(); anEdgeIter.Next())
423     aWireData->Add(TopoDS::Edge(anEdgeIter.Value()));
424
425   aWireOrder.KeepLoopsMode() = isKeepLoopsMode;
426   aWireAnalyzer = aShFixWire->Analyzer();
427   aWireAnalyzer->CheckOrder(aWireOrder, Standard_True);
428
429   aShFixWire->FixReorder(aWireOrder);
430   isDone = !aShFixWire->StatusReorder(ShapeExtend_FAIL);
431   if (!isDone)
432     return Standard_False;
433
434   if (isFixConnectedMode)
435   {
436     aShFixWire->ModifyTopologyMode() = Standard_True;
437     aShFixWire->FixConnected(theTolerance);
438   }
439
440   aWire = aWireData->Wire();
441
442 //   if (aWire.Closed())
443 //   {
444 //     theListOfWires.Append(aWire);
445 //     return Standard_True;
446 //   }
447
448   Standard_Integer i;
449   BRep_Builder     aBuilder;
450   TopoDS_Wire      aCurWire;
451   TopoDS_Vertex    aVf;
452   TopoDS_Vertex    aVl;
453   TopoDS_Vertex    aVlast;
454   Standard_Integer aNbEdges = aWireData->NbEdges();
455
456   aBuilder.MakeWire(aCurWire);
457   if (aNbEdges >= 1)
458   {
459     TopoDS_Edge anE = aWireData->Edge(1);
460     TopExp::Vertices(anE, aVf, aVlast, Standard_True);
461     aBuilder.Add(aCurWire, anE);
462   }
463
464   for(i = 2; i <= aNbEdges; i++)
465   {
466     TopoDS_Edge anE = aWireData->Edge(i);
467     TopExp::Vertices(anE, aVf, aVl, Standard_True);
468     if (aVf.IsSame(aVlast))
469     {
470       aBuilder.Add(aCurWire, anE);
471       aVlast = aVl;
472     }
473     else
474     {
475       aVlast = aVl;
476       TopExp::Vertices(aCurWire, aVf, aVl);
477       if (aVf.IsSame(aVl))
478         aCurWire.Closed(Standard_True);
479       theListOfWires.Append(aCurWire);
480       aBuilder.MakeWire(aCurWire);
481       aBuilder.Add(aCurWire, anE);
482     }
483   }
484
485   TopExp::Vertices(aCurWire, aVf, aVl);
486   if (aVf.IsSame(aVl))
487     aCurWire.Closed(Standard_True);
488   theListOfWires.Append(aCurWire);
489
490   return Standard_True;
491 }
492
493 Standard_Boolean BuildWires(const TopTools_ListOfShape &theListOfEdges,
494                                      TopTools_ListOfShape       &theListOfWires,
495                                      const Standard_Boolean      isFixConnectedMode = Standard_False,
496                                      const Standard_Boolean      isKeepLoopsMode = Standard_True,
497                                      const Standard_Real         theTolerance = Precision::Confusion())
498 {
499   Handle(ShapeBuild_ReShape) aReshape = new ShapeBuild_ReShape;
500   return BuildWiresWithReshape (aReshape, theListOfEdges, theListOfWires,
501                                 isFixConnectedMode, isKeepLoopsMode, theTolerance);
502 }
503
504 Standard_Boolean BuildBoundWires(const TopoDS_Shape   &theShell,
505                                           TopTools_ListOfShape &theListOfWires)
506 {
507   TopTools_IndexedDataMapOfShapeListOfShape
508                                anEdgeFaceMap;
509   Standard_Integer             i;
510   Standard_Boolean             isBound;
511   TopTools_ListOfShape         aBoundaryEdges;
512
513   TopExp::MapShapesAndAncestors(theShell, TopAbs_EDGE, TopAbs_FACE, anEdgeFaceMap);
514
515   isBound = Standard_False;
516   for (i = 1; i <= anEdgeFaceMap.Extent(); i++)
517   {
518     const TopTools_ListOfShape &anAncestFaces = anEdgeFaceMap.FindFromIndex(i);
519     if (anAncestFaces.Extent() == 1)
520     {
521       const TopoDS_Edge &anEdge = TopoDS::Edge(anEdgeFaceMap.FindKey(i));
522       if (!BRep_Tool::Degenerated(anEdge))
523       {
524         aBoundaryEdges.Append(anEdge);
525         isBound = Standard_True;
526       }
527     }
528   }
529
530   if (!isBound)
531     return Standard_True;
532
533   return BuildWires(aBoundaryEdges, theListOfWires);
534 }
535
536 static Standard_Integer BUC60868 (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
537 {
538   if (argc != 3) {
539     di << "Usage : " <<argv[0] << " Result Shell\n";
540     return 1;
541   }
542
543   TopoDS_Shape aShell = DBRep::Get(argv[2]);
544
545   if (aShell.IsNull()) {
546     di << "Faulty : The shape is NULL\n";
547     return 1;
548   }
549
550   TopTools_ListOfShape               aListOfWires;
551   BuildBoundWires(aShell, aListOfWires);
552
553   TopoDS_Shape aRes;
554   if (aListOfWires.IsEmpty())
555     di << "no bound\n";
556   else if (aListOfWires.Extent() == 1)
557     aRes = aListOfWires.First();
558   else {
559     BRep_Builder aBld;
560     aBld.MakeCompound (TopoDS::Compound(aRes));
561     TopTools_ListIteratorOfListOfShape aWireIter (aListOfWires);
562     for(; aWireIter.More(); aWireIter.Next())
563       aBld.Add (aRes, aWireIter.Value());
564   }
565
566   DBRep::Set(argv[1], aRes);
567   return 0;
568 }
569
570 static Standard_Integer BUC60924 (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
571 {
572   if (argc != 5) {
573     di << "Usage : " <<argv[0] << " curve X Y Z\n";
574     return 1;
575   }
576
577   Handle(Geom_Curve) aCurve = DrawTrSurf::GetCurve(argv[1]);
578
579   if (aCurve.IsNull()) {
580     di << "Faulty : the curve is NULL.\n";
581     return 1;
582   }
583   
584   gp_XYZ aVec(Draw::Atof(argv[2]),Draw::Atof(argv[3]),Draw::Atof(argv[4]));
585   
586   Standard_Boolean isPlanar=Standard_False;
587   isPlanar=ShapeAnalysis_Curve::IsPlanar(aCurve,aVec,1e-7);
588   
589   if(isPlanar)
590     di << "The curve is planar !\n";
591   else 
592     di << "Faulty : the curve is not planar!\n";
593   
594   return 0;
595 }
596
597 static Standard_Integer  BUC60920(Draw_Interpretor& di, Standard_Integer /*argc*/, const char ** argv)
598 {
599
600   Handle(AIS_InteractiveContext) myAISContext = ViewerTest::GetAISContext();
601   if(myAISContext.IsNull()) {
602     std::cerr << "use 'vinit' command before " << argv[0] << "\n";
603     return -1;
604   }
605
606   di.Eval("box b 10 10 10");
607   di.Eval("box w 20 20 20");
608   di.Eval("explode w e");
609
610   di.Eval(" vdisplay b");
611   di.Eval("vsetdispmode 1");
612
613   const char * Shname="w_11";
614   TopoDS_Shape theShape =  DBRep::Get(Shname);
615
616   Handle(AIS_Shape) anAISShape = new AIS_Shape( theShape ); 
617   myAISContext->Display( anAISShape, Standard_True );
618   
619   Handle(V3d_View) myV3dView = ViewerTest::CurrentView();
620   
621   double Xv,Yv;
622   myV3dView->Project(20,20,0,Xv,Yv);
623 //  std::cout<<Xv<<"\t"<<Yv<<std::endl;
624   
625   Standard_Integer Xp,Yp;
626   myV3dView->Convert(Xv,Yv,Xp,Yp);
627 //  std::cout<<Xp<<"\t"<<Yp<<std::endl;
628
629   myAISContext->MoveTo (Xp,Yp, myV3dView, Standard_True);
630
631 //   if (myAISContext->IsHilighted(anAISShape)) 
632 //              std::cout << "has hilighted shape : OK"   << std::endl;
633 //   else       std::cout << "has hilighted shape : bugged - Faulty "   << std::endl;
634   
635   return 0;
636 }
637
638 #include <LDOMParser.hxx>
639 static Standard_Integer  OCC983 (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
640 {
641   if (argc != 2) {
642     di << "Usage : " << argv[0] << " file\n";
643     return 1;
644   }
645
646   LDOMParser aParser;
647   LDOM_Document myDOM;
648
649   const char *File = (argv[1]);
650
651   if(!aParser.parse(File)) {
652     myDOM=aParser.getDocument();
653     di<<"Document parsed\n";
654   } else {
655     di<<"Document not parsed\n";
656     return 0;
657   }
658
659   LDOM_Element root = myDOM.getDocumentElement();
660
661   if ( root.isNull() ) {
662     di<<"Root element is null\n";
663     return 0;
664   }
665
666   TCollection_AsciiString RootName = root.getTagName();
667   di << "   RootName = " << RootName.ToCString() << "\n";
668   LDOM_NodeList aChildList = root.GetAttributesList();
669   for(Standard_Integer i=0,n=aChildList.getLength();i<n;i++) {
670     LDOM_Node item = aChildList.item(i);
671     TCollection_AsciiString itemName = item.getNodeName();
672     TCollection_AsciiString itemValue = item.getNodeValue();
673     di << "       AttributeName = " << itemName.ToCString() << "\n";
674     di << "       AttributeValue = " << itemValue.ToCString() << "\n";
675   }
676
677   LDOM_Element element;
678   LDOM_Node    node;
679   for ( node = root.getFirstChild(), element = (const LDOM_Element&) node;
680        !element.isNull();
681         node = element.getNextSibling(), element = (const LDOM_Element&) node) {
682     TCollection_AsciiString ElementName = element.getTagName();
683     di << "   ElementName = " << ElementName.ToCString() << "\n";
684     LDOM_NodeList aChildList2 = element.GetAttributesList();
685     for(Standard_Integer i2=0,n2=aChildList2.getLength();i2<n2;i2++) {
686       LDOM_Node item2 = aChildList2.item(i2);
687       TCollection_AsciiString itemName2 = item2.getNodeName();
688       TCollection_AsciiString itemValue2 = item2.getNodeValue();
689       di << "       AttributeName = " << itemName2.ToCString() << "\n";
690       di << "       AttributeValue = " << itemValue2.ToCString() << "\n";
691     }
692   }
693   if (aParser.GetBOM() != LDOM_OSStream::BOM_UNDEFINED)
694   {
695     di << "BOM is ";
696     switch (aParser.GetBOM()) {
697     case LDOM_OSStream::BOM_UTF8: di << "UTF-8"; break;
698     case LDOM_OSStream::BOM_UTF16BE: di << "UTF-16 (BE)"; break;
699     case LDOM_OSStream::BOM_UTF16LE: di << "UTF-16 (LE)"; break;
700     case LDOM_OSStream::BOM_UTF32BE: di << "UTF-32 (BE)"; break;
701     case LDOM_OSStream::BOM_UTF32LE: di << "UTF-32 (LE)"; break;
702     case LDOM_OSStream::BOM_UTF7: di << "UTF-7"; break;
703     case LDOM_OSStream::BOM_UTF1: di << "UTF-1"; break;
704     case LDOM_OSStream::BOM_UTFEBCDIC: di << "UTF-EBCDIC"; break;
705     case LDOM_OSStream::BOM_SCSU: di << "SCSU"; break;
706     case LDOM_OSStream::BOM_BOCU1: di << "BOCU-1"; break;
707     case LDOM_OSStream::BOM_GB18030: di << "GB-18030"; break;
708     default: di << "unexpected";
709     }
710     di << "\n";
711   }
712
713   return 0;
714 }
715
716 static Standard_Integer  OCC984 (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
717 {
718   if (argc != 2) {
719     di << "Usage : " << argv[0] << " file\n";
720     return 1;
721   }
722
723   LDOMParser aParser;
724   LDOM_Document myDOM;
725
726   //Standard_Character  *File = new Standard_Character [100];
727   //Sprintf(File,"%s",argv[1]);
728   const char *File = (argv[1]);
729
730   if(!aParser.parse(File)) {
731     myDOM=aParser.getDocument();
732     di<<"Document parsed\n";
733   } else {
734     di<<"Document not parsed\n";
735   }
736
737   return 0;
738 }
739
740 //#include <math.h>
741 // See QAOCC.cxx OCC6143
742 //static Standard_Integer OCC1723 (Draw_Interpretor& /*di*/, Standard_Integer argc, const char ** argv)
743 //{
744 //  if( argc != 1)
745 //  {
746 //    std::cout << "Usage : " << argv[0] << std::endl;
747 //    return 1;
748 //  }
749 //
750 //  Standard_Boolean isBad = Standard_False, isCaught;
751 //
752 //  // Case 1
753 //  isCaught = Standard_False;
754 //  {
755 //    try {
756 //      OCC_CATCH_SIGNALS
757 //      Standard_Integer a = 1;
758 //      Standard_Integer b = 0;
759 //      Standard_Integer c = a / b;
760 //    }
761 //    catch ( Standard_Failure ) {
762 //      isCaught = Standard_True;
763 //      std::cout << "OCC1723 Case 1 : OK" << std::endl;
764 //    }
765 //  }
766 //  isBad = isBad || !isCaught;
767 //
768 //  // Case 2
769 //  isCaught = Standard_False;
770 //  {
771 //    try {
772 //      OCC_CATCH_SIGNALS
773 //      Standard_Real d = -1.0;
774 //      Standard_Real e = sqrt(d);
775 //    }
776 //    catch ( Standard_Failure ) {
777 //      isCaught = Standard_True;
778 //      std::cout << "OCC1723 Case 2 : OK" << std::endl;
779 //    }
780 //  }
781 //  isBad = isBad || !isCaught;
782 //
783 //  // Case 3
784 //  isCaught = Standard_False;
785 //  {
786 //    try {
787 //      OCC_CATCH_SIGNALS
788 //      Standard_Real f = 1.0e-200;
789 //      Standard_Real g = 1.0e-200;
790 //      Standard_Real h = f * g;
791 //    }
792 //    catch ( Standard_Failure ) {
793 //      isCaught = Standard_True;
794 //      std::cout << "OCC1723 Case 3 : OK" << std::endl;
795 //    }
796 //  }
797 //  // MSV: underflow is not caught
798 //  //isBad = isBad || !isCaught;
799 //
800 //  // Case 4
801 //  isCaught = Standard_False;
802 //  {
803 //    try {
804 //      OCC_CATCH_SIGNALS
805 //      Standard_Real i = 1.0e+200;
806 //      Standard_Real j = 1.0e+200;
807 //      Standard_Real k = i * j;
808 //    }
809 //    catch ( Standard_Failure ) {
810 //      isCaught = Standard_True;
811 //      std::cout << "OCC1723 Case 4 : OK" << std::endl;
812 //    }
813 //  }
814 //  isBad = isBad || !isCaught;
815 //
816 //  if (isBad) {
817 //    std::cout << "OCC1723 : Error" << std::endl;
818 //  } else {
819 //    std::cout << "OCC1723 : OK" << std::endl;
820 //  }
821 //
822 //  return 0;
823 //}
824
825 #include <locale.h>
826 static Standard_Integer OCC1919_get (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
827 {
828   if( argc != 1)
829   {
830     di << "Usage : " << argv[0] << "\n";
831     return 1;
832   }
833   const TCollection_AsciiString anOldNumLocale =
834     (Standard_CString) setlocale (LC_NUMERIC, NULL);
835   di << "LC_NUMERIC = " << anOldNumLocale.ToCString() << "\n";
836   return 0;
837 }
838 static Standard_Integer OCC1919_set (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
839 {
840   if( argc != 2)
841   {
842     di << "Usage : " << argv[0] << " LC_NUMERIC\n";
843     return 1;
844   }
845   TCollection_AsciiString aNumLocale(argv[1]);
846   setlocale(LC_ALL, "") ;
847   setlocale(LC_NUMERIC, aNumLocale.ToCString()) ;
848   return 0;
849 }
850 #include <DDF.hxx>
851 #include <TDF_Label.hxx>
852 #include <TDataStd_Real.hxx>
853 #include <NCollection_BaseMap.hxx>
854 static Standard_Integer OCC1919_real (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
855 {
856   if (argc == 4) {
857     Handle(TDF_Data) DF;
858     if (!DDF::GetDF(argv[1],DF)) return 1;
859     TDF_Label L;
860     DDF::AddLabel(DF, argv[2], L);
861
862     //TDataStd_Real::Set(L,Draw::Atof(arg[3]));
863     TCollection_AsciiString AsciiStringReal(argv[3]);
864     if (!AsciiStringReal.IsRealValue()) return 1;
865     Standard_Real aReal = AsciiStringReal.RealValue();
866     di << "aReal = " << aReal << "\n";
867
868     TDataStd_Real::Set(L,aReal);
869     return 0;
870   }
871   return 1;
872 }
873
874 #include <TDataStd_UAttribute.hxx>
875 static Standard_Integer OCC2932_SetIDUAttribute (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
876 {
877   if( argc != 5)
878   {
879     di << "Usage : " << argv[0] << " (DF, entry, oldLocalID, newLocalID)\n";
880     return 1;
881   }
882   Handle(TDF_Data) DF;
883   if (!DDF::GetDF(argv[1],DF)) return 1; 
884   TDF_Label label;
885   if( !DDF::FindLabel(DF, argv[2], label) ) {
886     di << "No label for entry " << argv[2] << "\n";
887     return 0;
888   }
889   Standard_GUID old_guid(argv[3]);  //"00000000-0000-0000-2222-000000000000");
890   Standard_GUID new_guid(argv[4]);  //"00000000-0000-0000-2222-000000000001");
891
892   Handle(TDataStd_UAttribute) UA;    
893   if( !label.FindAttribute(old_guid, UA) ) {
894     di << "No UAttribute Attribute on label " << argv[2] << "\n";
895     return 0;
896   }
897   Handle(TDataStd_UAttribute) anotherUA;    
898   if( label.FindAttribute(new_guid, anotherUA) ) {
899     di << "There is this UAttribute Attribute on label " << argv[2] << "\n";
900     return 0;
901   }
902   UA->SetID(new_guid);
903   return 0;  
904 }
905
906 static Standard_Integer OCC2932_SetTag (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
907 {
908   if( argc != 4)
909   {
910     di << "Usage : " << argv[0] << " (DF, entry, Tag)\n";
911     return 1;
912   }
913   Handle(TDF_Data) DF;
914   if (!DDF::GetDF(argv[1],DF)) return 1;
915   TDF_Label L;
916   DDF::AddLabel(DF, argv[2], L);
917   Standard_Integer Tag = Draw::Atoi(argv[3]);
918   Handle(TDF_TagSource) A = TDF_TagSource::Set(L);
919   A->Set(Tag);
920   return 0;
921 }
922
923 #include <TDataStd_Current.hxx>
924 static Standard_Integer OCC2932_SetCurrent (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
925 {
926   if( argc != 3)
927   {
928     di << "Usage : " << argv[0] << " (DF, entry)\n";
929     return 1;
930   }
931   Handle(TDF_Data) DF;
932   if (!DDF::GetDF(argv[1],DF)) return 1;
933   TDF_Label L;
934   DDF::AddLabel(DF, argv[2], L);
935   TDataStd_Current::Set(L);  
936   return 0;
937 }
938
939 #include <TDataStd_Expression.hxx>
940 static Standard_Integer OCC2932_SetExpression (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
941 {
942   if( argc != 4)
943   {
944     di << "Usage : " << argv[0] << " (DF, entry, Expression)\n";
945     return 1;
946   }
947   Handle(TDF_Data) DF;
948   if (!DDF::GetDF(argv[1],DF)) return 1;
949   TDF_Label L;
950   DDF::AddLabel(DF, argv[2], L);
951   TCollection_ExtendedString Expression(argv[3]);
952   Handle(TDataStd_Expression) A = TDataStd_Expression::Set(L);
953   A->SetExpression(Expression);
954   return 0;
955 }
956
957 #include <TDataStd_Relation.hxx>
958 static Standard_Integer OCC2932_SetRelation (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
959 {
960   if( argc != 4)
961   {
962     di << "Usage : " << argv[0] << " (DF, entry, Relation)\n";
963     return 1;
964   }
965   Handle(TDF_Data) DF;
966   if (!DDF::GetDF(argv[1],DF)) return 1;
967   TDF_Label L;
968   DDF::AddLabel(DF, argv[2], L);
969   TCollection_ExtendedString Relation(argv[3]);
970   Handle(TDataStd_Relation) A = TDataStd_Relation::Set(L);
971   A->SetRelation(Relation);
972   return 0;
973 }
974
975 static Standard_Integer OCC3277 (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
976 {
977   if( argc != 2)
978   {
979     di << "Usage : " << argv[0] << " string\n";
980     return 1;
981   }
982   TCollection_ExtendedString ExtendedString;
983   TCollection_ExtendedString InputString(argv[1]);
984   ExtendedString.Cat(InputString);
985   //ExtendedString.Print(std::cout);
986   Standard_SStream aSStream;
987   ExtendedString.Print(aSStream);
988   di << aSStream;
989   return 0;
990 }
991
992 static Standard_Integer OCC6794 (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
993 {
994   if (argc > 2)
995     {
996       di << "Usage: " << argv[0] << " [nb]\n";
997       return 1;
998     }
999
1000   char* max = ::getenv( "MMGT_THRESHOLD" );
1001   
1002   Standard_Integer aNb = 1;
1003   if ( max )
1004     aNb += Draw::Atoi( max );
1005   else
1006     aNb += 40000;
1007
1008   if ( argc > 1 )
1009     aNb = Draw::Atoi( argv[1] );
1010
1011   di << "Use nb = " << aNb << "\n";
1012
1013   const char* c = "a";
1014   {
1015     TCollection_AsciiString anAscii;
1016     for ( int i = 1; i <= aNb; i++ ) {
1017       anAscii += TCollection_AsciiString( c );
1018     }
1019     Standard_Integer aLength = anAscii.Length();
1020     di << "aLength = " << aLength << "\n";
1021   }
1022   return 0;
1023 }
1024
1025 static Standard_Integer OCC16485 (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
1026 {
1027   if (argc > 1)
1028     {
1029       di << "Usage: " << argv[0] << "\n";
1030       return 1;
1031     }
1032
1033   // Create points with X co-ordinate from varying from 0. to 1000.
1034   // anc compute cumulative bounding box by adding boxes for all the 
1035   // points, enlarged on tolerance
1036   
1037   Standard_Real tol = 1e-3;
1038   int nbstep = 1000;
1039   Bnd_Box Box;
1040   for ( int i=0; i <= nbstep; i++ )
1041   {
1042     gp_Pnt p(i, 0., 0.);
1043     Bnd_Box B;
1044     B.Add(p);
1045     B.Enlarge(tol);
1046     B.Add ( Box ); 
1047     Box = B; // in this case XMin of Box will grow each time
1048   }
1049   
1050   Standard_Real xmin, ymin, zmin, xmax, ymax, zmax;
1051   Box.Get (xmin, ymin, zmin, xmax, ymax, zmax);
1052   //std::cout.precision(16);
1053   //std::cout << "Resulting dimensions: Xmin = " << xmin << " , Xmax = " << xmax << " , Tolerance = " << tol << std::endl;
1054   di << "Resulting dimensions: Xmin = " << xmin << " , Xmax = " << xmax << " , Tolerance = " << tol << "\n";
1055   if ( Abs ( xmin + tol ) > 1e-10 )
1056       di << "TEST FAILED: Xmin must be equal to -1e3!\n";
1057   else
1058       di << "TEST OK\n";
1059       //std::cout << "TEST FAILED: Xmin must be equal to -1e3!" << std::endl;
1060       //std::cout << "TEST OK" << std::endl;
1061       //di << "TEST FAILED: Xmin must be equal to -1e3!\n";
1062       //di << "TEST OK\n";
1063   return 0;
1064 }
1065 //Resulting dimensions: Xmin = -0.001 , Xmax = 1000.001 , Tolerance = 0.001
1066 //TEST OK
1067
1068 void QABugs::Commands_14(Draw_Interpretor& theCommands) {
1069   const char *group = "QABugs";
1070
1071   theCommands.Add ("BUC60897", "BUC60897", __FILE__, BUC60897, group);
1072   theCommands.Add ("BUC60889", "BUC60889 point_1 point_2 name_of_edge bndbox_X1 bndbox_Y1 bndbox_Z1 bndbox_X2 bndbox_Y2 bndbox_Z2", __FILE__, BUC60889, group);
1073   theCommands.Add ("BUC60852", "BUC60852 name_of_edge bndbox_X1 bndbox_Y1 bndbox_Z1 bndbox_X2 bndbox_Y2 bndbox_Z2", __FILE__, BUC60852, group);
1074   theCommands.Add ("BUC60854", "BUC60854 result_shape name_of_shape name_of_face name_of_wire/name_of_edge [ name_of_wire/name_of_edge ... ] [ name_of_face name_of_wire/name_of_edge [ name_of_wire/name_of_edge ... ] ... ] [ @ edge_on_shape edge_on_wire [ edge_on_shape edge_on_wire ... ] ] [ # L/R ]", __FILE__, BUC60854, group);
1075   theCommands.Add ("BUC60870", "BUC60870 result name_of_shape_1 name_of_shape_2 dev", __FILE__, BUC60870, group);
1076   theCommands.Add ("BUC60902", "BUC60902", __FILE__, BUC60902, group);
1077   theCommands.Add ("BUC60944", "BUC60944 path", __FILE__, BUC60944, group);
1078   theCommands.Add ("BUC60868", "BUC60868 Result Shell", __FILE__, BUC60868, group);
1079   theCommands.Add ("BUC60924", "BUC60924 curve X Y Z", __FILE__, BUC60924, group);
1080   theCommands.Add ("BUC60920", "BUC60920", __FILE__, BUC60920, group);
1081   theCommands.Add ("OCC983", "OCC983 file", __FILE__, OCC983, group);
1082   theCommands.Add ("OCC984", "OCC984 file", __FILE__, OCC984, group);
1083
1084 //  theCommands.Add ("OCC1723", "OCC1723", __FILE__, OCC1723, group);
1085
1086   theCommands.Add ("OCC1919_get", "OCC1919_get", __FILE__, OCC1919_get, group);
1087
1088   theCommands.Add ("OCC1919_set", "OCC1919_set LC_NUMERIC", __FILE__, OCC1919_set, group);
1089
1090   theCommands.Add ("OCC1919_real", "OCC1919_real (DF, entry, value)", __FILE__, OCC1919_real, group);
1091
1092   theCommands.Add ("OCC2932_SetIDUAttribute", "OCC2932_SetIDUAttribute (DF, entry, oldLocalID, newLocalID)", __FILE__, OCC2932_SetIDUAttribute, group);
1093
1094   theCommands.Add ("OCC2932_SetTag", "OCC2932_SetTag (DF, entry, Tag)", __FILE__, OCC2932_SetTag, group);
1095
1096   theCommands.Add ("OCC2932_SetCurrent", "OCC2932_SetCurrent (DF, entry)", __FILE__, OCC2932_SetCurrent, group);
1097
1098   theCommands.Add ("OCC2932_SetExpression", "OCC2932_SetExpression (DF, entry, Expression)", __FILE__, OCC2932_SetExpression, group);
1099
1100   theCommands.Add ("OCC2932_SetRelation", "OCC2932_SetRelation (DF, entry, Relation)", __FILE__, OCC2932_SetRelation, group);
1101
1102   theCommands.Add ("OCC3277", "OCC3277 string", __FILE__, OCC3277, group);
1103
1104   theCommands.Add ("OCC6794", "OCC6794 [nb]", __FILE__, OCC6794, group);
1105
1106   theCommands.Add ("OCC16485", "OCC16485", __FILE__, OCC16485, group);
1107
1108   return;
1109 }