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 << "\n" << "tangency1 : X " << aPnt2d1.X() << " Y " << aPnt2d1.Y();
 103     di << "\n" << "tangency2 : 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 u,v;
 218           DBRep_DrawableShape::LastPick(W,u,v);
 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   for (i++; i<argc; i+=2) {
 243     TopoDS_Shape Ew,Es;
 244     TopoDS_Shape aLocalShape(DBRep::Get(argv[i],TopAbs_EDGE));
 245     Es = TopoDS::Edge(aLocalShape);
 246     if (Es.IsNull()) {
 247       return 1;
 248     }
 249     aLocalShape = DBRep::Get(argv[i+1],TopAbs_EDGE);
 250     Ew = TopoDS::Edge(aLocalShape);
 251     if (Ew.IsNull()) {
 252       return 1;
 253     }
 254     Spls.Add(TopoDS::Edge(Ew),TopoDS::Edge(Es));
 255   }
 256   Spls.Build();
 257   const TopTools_ListOfShape& aLeftPart = Spls.Left();
 258   BRep_Builder BB;
 259   TopoDS_Shape aShell;
 260   BB.MakeShell(TopoDS::Shell(aShell));
 261   TopTools_ListIteratorOfListOfShape anIter(aLeftPart);
 262   for(; anIter.More(); anIter.Next()) BB.Add(aShell, anIter.Value());
 263   aShell.Closed (BRep_Tool::IsClosed (aShell));
 264   DBRep::Set(argv[1],aShell);
 265   return 0;
 266 }
 267
 268 static Standard_Integer BUC60870 (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
 269 {
 270   Standard_Integer i1;
 271   if (argc != 5) {
 272     di << "Usage : " << argv[0] << " result name_of_shape_1 name_of_shape_2 dev" << "\n";
 273     return 1;
 274   }
 275   const char *ns1 = (argv[2]), *ns2 = (argv[3]), *ns0 = (argv[1]);
 276   TopoDS_Shape S1(DBRep::Get(ns1)), S2(DBRep::Get(ns2))  ;
 277   Standard_Real dev =  Draw::Atof(argv[4]);
 278   BRepExtrema_DistShapeShape dst(S1 ,S2, dev );
 279   if (dst.IsDone()) {
 280     char named[100];
 281     Sprintf(named, "%s%s" ,ns0,"_val");
 282     char* tempd = named;
 283     Draw::Set(tempd,dst.Value());
 284     di << named << " ";
 285     for (i1=1; i1<= dst.NbSolution(); i1++) {
 286       gp_Pnt P1,P2;
 287       P1 = (dst.PointOnShape1(i1));
 288       P2 = (dst.PointOnShape2(i1));
 289       if (dst.Value()<=1.e-9) {
 290         TopoDS_Vertex V =BRepLib_MakeVertex(P1);
 291         char namev[100];
 292         if (i1==1) {
 293           Sprintf(namev, "%s" ,ns0);
 294         } else {
 295           Sprintf(namev, "%s%d" ,ns0,i1);
 296         }
 297         char* tempv = namev;
 298         DBRep::Set(tempv,V);
 299         di << namev << " ";
 300       } else {
 301         char name[100];
 302         TopoDS_Edge E = BRepLib_MakeEdge (P1, P2);
 303         if (i1==1) {
 304           Sprintf(name,"%s",ns0);
 305         } else {
 306           Sprintf(name,"%s%d",ns0,i1);
 307         }
 308         char* temp = name;
 309         DBRep::Set(temp,E);
 310         di << name << " " ;
 311       }
 312     }
 313   } else {
 314     di << "Faulty : found a problem"<< "\n";
 315   }
 316   return 0;
 317 }
 318
 319 static Standard_Integer BUC60902 (Draw_Interpretor& di, Standard_Integer /*argc*/, const char ** /*argv*/)
 320 {
 321   Handle(TColgp_HArray1OfPnt) aPnts = new TColgp_HArray1OfPnt(1,5);
 322   gp_Pnt aP(0., 0., 0.);
 323   for(Standard_Integer i = 1; i <= 5; i++) {
 324     aP.SetX((i-1)*1.57);
 325     aP.SetY(Sin((i-1)*1.57));
 326     aPnts->SetValue(i, aP);
 327   }
 328   GeomAPI_Interpolate anInterpolater(aPnts, Standard_False, Precision::Confusion());
 329   anInterpolater.Perform();
 330   if(!anInterpolater.IsDone()) {
 331     di << "Faulty : error in interpolation" << "\n";
 332     return 1;
 333   }
 334   Handle(Geom_BSplineCurve) aCur = anInterpolater.Curve();
 335   gp_Vec aFirstTang, aLastTang;
 336   aCur->D1(aCur->FirstParameter(), aP, aFirstTang);
 337   aCur->D1(aCur->LastParameter(), aP, aLastTang);
 338   di << " Used Tang1 = " << aFirstTang.X() << " " << aFirstTang.Y() << " " << aFirstTang.Z() << "\n";
 339   di << " Used Tang2 = " << aLastTang.X() << " " << aLastTang.Y() << " " << aLastTang.Z() << "\n";
 340   GeomAPI_Interpolate anInterpolater1(aPnts, Standard_False, Precision::Confusion());
 341   anInterpolater1.Load(aFirstTang, aLastTang, Standard_False);
 342   anInterpolater1.Perform();
 343   if(!anInterpolater1.IsDone()) {
 344     di << "Faulty : error in interpolation 1" << "\n";
 345     return 1;
 346   }
 347   aCur = anInterpolater1.Curve();
 348   gp_Vec aFirstTang1, aLastTang1;
 349   aCur->D1(aCur->FirstParameter(), aP, aFirstTang1);
 350   aCur->D1(aCur->LastParameter(), aP, aLastTang1);
 351   di << " Tang1 after compute = " << aFirstTang1.X() << " " << aFirstTang1.Y() << " " << aFirstTang1.Z() << "\n";
 352   di << " Tang2 after compute = " << aLastTang1.X() << " " << aLastTang1.Y() << " " << aLastTang1.Z() << "\n";
 353   if(aFirstTang.IsEqual(aFirstTang1, Precision::Confusion(), Precision::Angular())) {
 354     di << "First tangent is OK" << "\n";
 355   }
 356   else {
 357     di << "Faulty : first tangent is wrong" << "\n";
 358   }
 359   if(aLastTang.IsEqual(aLastTang1, Precision::Confusion(), Precision::Angular())) {
 360     di << "Last tangent is OK" << "\n";
 361   }
 362   else {
 363     di << "Faulty : last tangent is wrong" << "\n";
 364   }
 365   return 0;
 366 }
 367
 368 static Standard_Integer BUC60944 (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
 369 {
 370   if(argc != 2) {
 371     di << "Usage : " << argv[0] << " path" << "\n";
 372   }
 373
 374   TCollection_AsciiString in(argv[1]);
 375   OSD_Path* aPath = new OSD_Path(in);
 376   TCollection_AsciiString out;
 377   aPath->SystemName(out);
 378   if(in == out)
 379     di << "The convertion is right." << "\n";
 380   else
 381     di << "Faulty : The convertion is incorrect : " << out.ToCString() << "\n";
 382   di << out.ToCString() << "\n";
 383 //  cout << aPath->Trek() << " !" << endl;
 384   return 0;
 385 }
 386
 387 Standard_Boolean BuildWiresWithReshape
 388                 (const Handle(ShapeBuild_ReShape)& theReshape,
 389                  const TopTools_ListOfShape &theListOfEdges,
 390                  TopTools_ListOfShape       &theListOfWires,
 391                  const Standard_Boolean      isFixConnectedMode,
 392                  const Standard_Boolean      isKeepLoopsMode,
 393                  const Standard_Real         theTolerance)
 394 {
 395   TopTools_ListIteratorOfListOfShape anEdgeIter;
 396   Standard_Boolean                   isDone;
 397   TopoDS_Wire                        aWire;
 398
 399   theListOfWires.Clear();
 400   Handle(ShapeExtend_WireData) aWireData  = new ShapeExtend_WireData;
 401   Handle(ShapeFix_Wire) aShFixWire = new ShapeFix_Wire;
 402   aShFixWire->SetContext (theReshape);
 403
 404   Handle(ShapeAnalysis_Wire) aWireAnalyzer;
 405   ShapeAnalysis_WireOrder aWireOrder;
 406
 407   aShFixWire->Load(aWireData);
 408   aShFixWire->SetPrecision(theTolerance);
 409
 410   for(anEdgeIter.Initialize(theListOfEdges); anEdgeIter.More(); anEdgeIter.Next())
 411     aWireData->Add(TopoDS::Edge(anEdgeIter.Value()));
 412
 413   aWireOrder.KeepLoopsMode() = isKeepLoopsMode;
 414   aWireAnalyzer = aShFixWire->Analyzer();
 415   aWireAnalyzer->CheckOrder(aWireOrder, Standard_True);
 416
 417   aShFixWire->FixReorder(aWireOrder);
 418   isDone = !aShFixWire->StatusReorder(ShapeExtend_FAIL);
 419   if (!isDone)
 420     return Standard_False;
 421
 422   if (isFixConnectedMode)
 423   {
 424     aShFixWire->ModifyTopologyMode() = Standard_True;
 425     aShFixWire->FixConnected(theTolerance);
 426   }
 427
 428   aWire = aWireData->Wire();
 429
 430 //   if (aWire.Closed())
 431 //   {
 432 //     theListOfWires.Append(aWire);
 433 //     return Standard_True;
 434 //   }
 435
 436   Standard_Integer i;
 437   BRep_Builder     aBuilder;
 438   TopoDS_Wire      aCurWire;
 439   TopoDS_Vertex    aVf;
 440   TopoDS_Vertex    aVl;
 441   TopoDS_Vertex    aVlast;
 442   Standard_Integer aNbEdges = aWireData->NbEdges();
 443
 444   aBuilder.MakeWire(aCurWire);
 445   if (aNbEdges >= 1)
 446   {
 447     TopoDS_Edge anE = aWireData->Edge(1);
 448     TopExp::Vertices(anE, aVf, aVlast, Standard_True);
 449     aBuilder.Add(aCurWire, anE);
 450   }
 451
 452   for(i = 2; i <= aNbEdges; i++)
 453   {
 454     TopoDS_Edge anE = aWireData->Edge(i);
 455     TopExp::Vertices(anE, aVf, aVl, Standard_True);
 456     if (aVf.IsSame(aVlast))
 457     {
 458       aBuilder.Add(aCurWire, anE);
 459       aVlast = aVl;
 460     }
 461     else
 462     {
 463       aVlast = aVl;
 464       TopExp::Vertices(aCurWire, aVf, aVl);
 465       if (aVf.IsSame(aVl))
 466         aCurWire.Closed(Standard_True);
 467       theListOfWires.Append(aCurWire);
 468       aBuilder.MakeWire(aCurWire);
 469       aBuilder.Add(aCurWire, anE);
 470     }
 471   }
 472
 473   TopExp::Vertices(aCurWire, aVf, aVl);
 474   if (aVf.IsSame(aVl))
 475     aCurWire.Closed(Standard_True);
 476   theListOfWires.Append(aCurWire);
 477
 478   return Standard_True;
 479 }
 480
 481 Standard_Boolean BuildWires(const TopTools_ListOfShape &theListOfEdges,
 482                                      TopTools_ListOfShape       &theListOfWires,
 483                                      const Standard_Boolean      isFixConnectedMode = Standard_False,
 484                                      const Standard_Boolean      isKeepLoopsMode = Standard_True,
 485                                      const Standard_Real         theTolerance = Precision::Confusion())
 486 {
 487   Handle(ShapeBuild_ReShape) aReshape = new ShapeBuild_ReShape;
 488   return BuildWiresWithReshape (aReshape, theListOfEdges, theListOfWires,
 489                                 isFixConnectedMode, isKeepLoopsMode, theTolerance);
 490 }
 491
 492 Standard_Boolean BuildBoundWires(const TopoDS_Shape   &theShell,
 493                                           TopTools_ListOfShape &theListOfWires)
 494 {
 495   TopTools_IndexedDataMapOfShapeListOfShape
 496                                anEdgeFaceMap;
 497   Standard_Integer             i;
 498   Standard_Boolean             isBound;
 499   TopTools_ListOfShape         aBoundaryEdges;
 500
 501   TopExp::MapShapesAndAncestors(theShell, TopAbs_EDGE, TopAbs_FACE, anEdgeFaceMap);
 502
 503   isBound = Standard_False;
 504   for (i = 1; i <= anEdgeFaceMap.Extent(); i++)
 505   {
 506     const TopTools_ListOfShape &anAncestFaces = anEdgeFaceMap.FindFromIndex(i);
 507     if (anAncestFaces.Extent() == 1)
 508     {
 509       const TopoDS_Edge &anEdge = TopoDS::Edge(anEdgeFaceMap.FindKey(i));
 510       if (!BRep_Tool::Degenerated(anEdge))
 511       {
 512         aBoundaryEdges.Append(anEdge);
 513         isBound = Standard_True;
 514       }
 515     }
 516   }
 517
 518   if (!isBound)
 519     return Standard_True;
 520
 521   return BuildWires(aBoundaryEdges, theListOfWires);
 522 }
 523
 524 static Standard_Integer BUC60868 (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
 525 {
 526   if (argc != 3) {
 527     di << "Usage : " <<argv[0] << " Result Shell" << "\n";
 528     return 1;
 529   }
 530
 531   TopoDS_Shape aShell = DBRep::Get(argv[2]);
 532
 533   if (aShell.IsNull()) {
 534     di << "Faulty : The shape is NULL" << "\n";
 535     return 1;
 536   }
 537
 538   TopTools_ListOfShape               aListOfWires;
 539   BuildBoundWires(aShell, aListOfWires);
 540
 541   TopoDS_Shape aRes;
 542   if (aListOfWires.IsEmpty())
 543     di << "no bound" << "\n";
 544   else if (aListOfWires.Extent() == 1)
 545     aRes = aListOfWires.First();
 546   else {
 547     BRep_Builder aBld;
 548     aBld.MakeCompound (TopoDS::Compound(aRes));
 549     TopTools_ListIteratorOfListOfShape aWireIter (aListOfWires);
 550     for(; aWireIter.More(); aWireIter.Next())
 551       aBld.Add (aRes, aWireIter.Value());
 552   }
 553
 554   DBRep::Set(argv[1], aRes);
 555   return 0;
 556 }
 557
 558 static Standard_Integer BUC60924 (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
 559 {
 560   if (argc != 5) {
 561     di << "Usage : " <<argv[0] << " curve X Y Z" << "\n";
 562     return 1;
 563   }
 564
 565   Handle(Geom_Curve) aCurve = DrawTrSurf::GetCurve(argv[1]);
 566
 567   if (aCurve.IsNull()) {
 568     di << "Faulty : the curve is NULL." << "\n";
 569     return 1;
 570   }
 571
 572   gp_XYZ aVec(Draw::Atof(argv[2]),Draw::Atof(argv[3]),Draw::Atof(argv[4]));
 573
 574   Standard_Boolean isPlanar=Standard_False;
 575   isPlanar=ShapeAnalysis_Curve::IsPlanar(aCurve,aVec,1e-7);
 576
 577   if(isPlanar)
 578     di << "The curve is planar !" << "\n";
 579   else
 580     di << "Faulty : the curve is not planar!" << "\n";
 581
 582   return 0;
 583 }
 584
 585 static Standard_Integer  BUC60920(Draw_Interpretor& di, Standard_Integer /*argc*/, const char ** argv)
 586 {
 587
 588   Handle(AIS_InteractiveContext) myAISContext = ViewerTest::GetAISContext();
 589   if(myAISContext.IsNull()) {
 590     cerr << "use 'vinit' command before " << argv[0] << "\n";
 591     return -1;
 592   }
 593
 594   di.Eval("box b 10 10 10");
 595   di.Eval("box w 20 20 20");
 596   di.Eval("explode w e");
 597
 598   di.Eval(" vdisplay b");
 599   di.Eval("vsetdispmode 1");
 600
 601   const char * Shname="w_11";
 602   TopoDS_Shape theShape =  DBRep::Get(Shname);
 603
 604   Handle(AIS_Shape) anAISShape = new AIS_Shape( theShape );
 605   myAISContext->Display( anAISShape, Standard_True );
 606
 607   Handle(V3d_View) myV3dView = ViewerTest::CurrentView();
 608
 609   double Xv,Yv;
 610   myV3dView->Project(20,20,0,Xv,Yv);
 611 //  cout<<Xv<<"\t"<<Yv<<endl;
 612
 613   Standard_Integer Xp,Yp;
 614   myV3dView->Convert(Xv,Yv,Xp,Yp);
 615 //  cout<<Xp<<"\t"<<Yp<<endl;
 616
 617   myAISContext->MoveTo( Xp,Yp, myV3dView  );
 618   myAISContext->MoveTo( Xp,Yp, myV3dView  );
 619
 620 //   if (myAISContext->IsHilighted(anAISShape))
 621 //              cout << "has hilighted shape : OK"   << endl;
 622 //   else       cout << "has hilighted shape : bugged - Faulty "   << endl;
 623
 624   return 0;
 625 }
 626
 627 #include <LDOMParser.hxx>
 628 static Standard_Integer  OCC983 (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
 629 {
 630   if (argc != 2) {
 631     di << "Usage : " << argv[0] << " file" << "\n";
 632     return 1;
 633   }
 634
 635   LDOMParser aParser;
 636   LDOM_Document myDOM;
 637
 638   const char *File = (argv[1]);
 639
 640   if(!aParser.parse(File)) {
 641     myDOM=aParser.getDocument();
 642     di<<"Document parsed"<<"\n";
 643   } else {
 644     di<<"Document not parsed"<<"\n";
 645     return 0;
 646   }
 647
 648   LDOM_Element root = myDOM.getDocumentElement();
 649
 650   if ( root.isNull() ) {
 651     di<<"Root element is null"<<"\n";
 652     return 0;
 653   }
 654
 655   TCollection_AsciiString RootName = root.getTagName();
 656   di << "   RootName = " << RootName.ToCString() << "\n";
 657   LDOM_NodeList aChildList = root.GetAttributesList();
 658   for(Standard_Integer i=0,n=aChildList.getLength();i<n;i++) {
 659     LDOM_Node item = aChildList.item(i);
 660     TCollection_AsciiString itemName = item.getNodeName();
 661     TCollection_AsciiString itemValue = item.getNodeValue();
 662     di << "       AttributeName = " << itemName.ToCString() << "\n";
 663     di << "       AttributeValue = " << itemValue.ToCString() << "\n";
 664   }
 665
 666 //  LDOM_Element element;
 667 //  for ( element = (const LDOM_Element&) root.getFirstChild();
 668 //       !element.isNull();
 669 //       element = (const LDOM_Element&) element.getNextSibling() ) {
 670   LDOM_Element element;
 671   LDOM_Node    node;
 672   for ( node = root.getFirstChild(), element = (const LDOM_Element&) node;
 673        !element.isNull();
 674         node = element.getNextSibling(), element = (const LDOM_Element&) node) {
 675     TCollection_AsciiString ElementName = element.getTagName();
 676     di << "   ElementName = " << ElementName.ToCString() << "\n";
 677     LDOM_NodeList aChildList2 = element.GetAttributesList();
 678     for(Standard_Integer i2=0,n2=aChildList2.getLength();i2<n2;i2++) {
 679       LDOM_Node item2 = aChildList2.item(i2);
 680       TCollection_AsciiString itemName2 = item2.getNodeName();
 681       TCollection_AsciiString itemValue2 = item2.getNodeValue();
 682       di << "       AttributeName = " << itemName2.ToCString() << "\n";
 683       di << "       AttributeValue = " << itemValue2.ToCString() << "\n";
 684     }
 685   }
 686
 687   return 0;
 688 }
 689
 690 static Standard_Integer  OCC984 (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
 691 {
 692   if (argc != 2) {
 693     di << "Usage : " << argv[0] << " file" << "\n";
 694     return 1;
 695   }
 696
 697   LDOMParser aParser;
 698   LDOM_Document myDOM;
 699
 700   //Standard_Character  *File = new Standard_Character [100];
 701   //Sprintf(File,"%s",argv[1]);
 702   const char *File = (argv[1]);
 703
 704   if(!aParser.parse(File)) {
 705     myDOM=aParser.getDocument();
 706     di<<"Document parsed"<<"\n";
 707   } else {
 708     di<<"Document not parsed"<<"\n";
 709   }
 710
 711   return 0;
 712 }
 713
 714 static Standard_Integer OCC1786 (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
 715 {
 716   if( argc != 2)
 717   {
 718     di << "Usage : " << argv[0] << " AutoHilight=0/1" << "\n";
 719     return 1;
 720   }
 721   Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
 722   if(aContext.IsNull())
 723   {
 724     cerr << "use 'vinit' command before " << argv[0] << "\n";
 725     return 1;
 726   }
 727   Standard_Integer AutoHilightInteger =  Draw::Atoi(argv[1]);
 728   Standard_Boolean AutoHilightBoolean = Standard_False;
 729   if (AutoHilightInteger != 0) {
 730      AutoHilightBoolean = Standard_True;
 731   }
 732   aContext->SetAutomaticHilight(AutoHilightBoolean);
 733   return 0;
 734 }
 735
 736 //#include <math.h>
 737 // See QAOCC.cxx OCC6143
 738 //static Standard_Integer OCC1723 (Draw_Interpretor& /*di*/, Standard_Integer argc, const char ** argv)
 739 //{
 740 //  if( argc != 1)
 741 //  {
 742 //    cout << "Usage : " << argv[0] << endl;
 743 //    return 1;
 744 //  }
 745 //
 746 //  Standard_Boolean isBad = Standard_False, isCaught;
 747 //
 748 //  // Case 1
 749 //  isCaught = Standard_False;
 750 //  {
 751 //    try {
 752 //      OCC_CATCH_SIGNALS
 753 //      Standard_Integer a = 1;
 754 //      Standard_Integer b = 0;
 755 //      Standard_Integer c = a / b;
 756 //    }
 757 //    catch ( Standard_Failure ) {
 758 //      isCaught = Standard_True;
 759 //      cout << "OCC1723 Case 1 : OK" << endl;
 760 //    }
 761 //  }
 762 //  isBad = isBad || !isCaught;
 763 //
 764 //  // Case 2
 765 //  isCaught = Standard_False;
 766 //  {
 767 //    try {
 768 //      OCC_CATCH_SIGNALS
 769 //      Standard_Real d = -1.0;
 770 //      Standard_Real e = sqrt(d);
 771 //    }
 772 //    catch ( Standard_Failure ) {
 773 //      isCaught = Standard_True;
 774 //      cout << "OCC1723 Case 2 : OK" << endl;
 775 //    }
 776 //  }
 777 //  isBad = isBad || !isCaught;
 778 //
 779 //  // Case 3
 780 //  isCaught = Standard_False;
 781 //  {
 782 //    try {
 783 //      OCC_CATCH_SIGNALS
 784 //      Standard_Real f = 1.0e-200;
 785 //      Standard_Real g = 1.0e-200;
 786 //      Standard_Real h = f * g;
 787 //    }
 788 //    catch ( Standard_Failure ) {
 789 //      isCaught = Standard_True;
 790 //      cout << "OCC1723 Case 3 : OK" << endl;
 791 //    }
 792 //  }
 793 //  // MSV: underflow is not caught
 794 //  //isBad = isBad || !isCaught;
 795 //
 796 //  // Case 4
 797 //  isCaught = Standard_False;
 798 //  {
 799 //    try {
 800 //      OCC_CATCH_SIGNALS
 801 //      Standard_Real i = 1.0e+200;
 802 //      Standard_Real j = 1.0e+200;
 803 //      Standard_Real k = i * j;
 804 //    }
 805 //    catch ( Standard_Failure ) {
 806 //      isCaught = Standard_True;
 807 //      cout << "OCC1723 Case 4 : OK" << endl;
 808 //    }
 809 //  }
 810 //  isBad = isBad || !isCaught;
 811 //
 812 //  if (isBad) {
 813 //    cout << "OCC1723 : Error" << endl;
 814 //  } else {
 815 //    cout << "OCC1723 : OK" << endl;
 816 //  }
 817 //
 818 //  return 0;
 819 //}
 820
 821 #include <locale.h>
 822 static Standard_Integer OCC1919_get (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
 823 {
 824   if( argc != 1)
 825   {
 826     di << "Usage : " << argv[0] << "\n";
 827     return 1;
 828   }
 829   const TCollection_AsciiString anOldNumLocale =
 830     (Standard_CString) setlocale (LC_NUMERIC, NULL);
 831   di << "LC_NUMERIC = " << anOldNumLocale.ToCString() << "\n";
 832   return 0;
 833 }
 834 static Standard_Integer OCC1919_set (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
 835 {
 836   if( argc != 2)
 837   {
 838     di << "Usage : " << argv[0] << " LC_NUMERIC" << "\n";
 839     return 1;
 840   }
 841   TCollection_AsciiString aNumLocale(argv[1]);
 842   setlocale(LC_ALL, "") ;
 843   setlocale(LC_NUMERIC, aNumLocale.ToCString()) ;
 844   return 0;
 845 }
 846 #include <DDF.hxx>
 847 #include <TDF_Label.hxx>
 848 #include <TDataStd_Real.hxx>
 849 #include <NCollection_BaseMap.hxx>
 850 static Standard_Integer OCC1919_real (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
 851 {
 852   if (argc == 4) {
 853     Handle(TDF_Data) DF;
 854     if (!DDF::GetDF(argv[1],DF)) return 1;
 855     TDF_Label L;
 856     DDF::AddLabel(DF, argv[2], L);
 857
 858     //TDataStd_Real::Set(L,Draw::Atof(arg[3]));
 859     TCollection_AsciiString AsciiStringReal(argv[3]);
 860     if (!AsciiStringReal.IsRealValue()) return 1;
 861     Standard_Real aReal = AsciiStringReal.RealValue();
 862     di << "aReal = " << aReal << "\n";
 863
 864     TDataStd_Real::Set(L,aReal);
 865     return 0;
 866   }
 867   return 1;
 868 }
 869
 870 #include <TDataStd_UAttribute.hxx>
 871 static Standard_Integer OCC2932_SetIDUAttribute (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
 872 {
 873   if( argc != 5)
 874   {
 875     di << "Usage : " << argv[0] << " (DF, entry, oldLocalID, newLocalID)" << "\n";
 876     return 1;
 877   }
 878   Handle(TDF_Data) DF;
 879   if (!DDF::GetDF(argv[1],DF)) return 1;
 880   TDF_Label label;
 881   if( !DDF::FindLabel(DF, argv[2], label) ) {
 882     di << "No label for entry " << argv[2] << "\n";
 883     return 0;
 884   }
 885   Standard_GUID old_guid(argv[3]);  //"00000000-0000-0000-2222-000000000000");
 886   Standard_GUID new_guid(argv[4]);  //"00000000-0000-0000-2222-000000000001");
 887
 888   Handle(TDataStd_UAttribute) UA;
 889   if( !label.FindAttribute(old_guid, UA) ) {
 890     di << "No UAttribute Attribute on label " << argv[2] << "\n";
 891     return 0;
 892   }
 893   Handle(TDataStd_UAttribute) anotherUA;
 894   if( label.FindAttribute(new_guid, anotherUA) ) {
 895     di << "There is this UAttribute Attribute on label " << argv[2] << "\n";
 896     return 0;
 897   }
 898   UA->SetID(new_guid);
 899   return 0;
 900 }
 901
 902 static Standard_Integer OCC2932_SetTag (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
 903 {
 904   if( argc != 4)
 905   {
 906     di << "Usage : " << argv[0] << " (DF, entry, Tag)" << "\n";
 907     return 1;
 908   }
 909   Handle(TDF_Data) DF;
 910   if (!DDF::GetDF(argv[1],DF)) return 1;
 911   TDF_Label L;
 912   DDF::AddLabel(DF, argv[2], L);
 913   Standard_Integer Tag = Draw::Atoi(argv[3]);
 914   Handle(TDF_TagSource) A = TDF_TagSource::Set(L);
 915   A->Set(Tag);
 916   return 0;
 917 }
 918
 919 #include <TDataStd_Current.hxx>
 920 static Standard_Integer OCC2932_SetCurrent (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
 921 {
 922   if( argc != 3)
 923   {
 924     di << "Usage : " << argv[0] << " (DF, entry)" << "\n";
 925     return 1;
 926   }
 927   Handle(TDF_Data) DF;
 928   if (!DDF::GetDF(argv[1],DF)) return 1;
 929   TDF_Label L;
 930   DDF::AddLabel(DF, argv[2], L);
 931   TDataStd_Current::Set(L);
 932   return 0;
 933 }
 934
 935 #include <TDataStd_Expression.hxx>
 936 static Standard_Integer OCC2932_SetExpression (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
 937 {
 938   if( argc != 4)
 939   {
 940     di << "Usage : " << argv[0] << " (DF, entry, Expression)" << "\n";
 941     return 1;
 942   }
 943   Handle(TDF_Data) DF;
 944   if (!DDF::GetDF(argv[1],DF)) return 1;
 945   TDF_Label L;
 946   DDF::AddLabel(DF, argv[2], L);
 947   TCollection_ExtendedString Expression(argv[3]);
 948   Handle(TDataStd_Expression) A = TDataStd_Expression::Set(L);
 949   A->SetExpression(Expression);
 950   return 0;
 951 }
 952
 953 #include <TDataStd_Relation.hxx>
 954 static Standard_Integer OCC2932_SetRelation (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
 955 {
 956   if( argc != 4)
 957   {
 958     di << "Usage : " << argv[0] << " (DF, entry, Relation)" << "\n";
 959     return 1;
 960   }
 961   Handle(TDF_Data) DF;
 962   if (!DDF::GetDF(argv[1],DF)) return 1;
 963   TDF_Label L;
 964   DDF::AddLabel(DF, argv[2], L);
 965   TCollection_ExtendedString Relation(argv[3]);
 966   Handle(TDataStd_Relation) A = TDataStd_Relation::Set(L);
 967   A->SetRelation(Relation);
 968   return 0;
 969 }
 970
 971 static Standard_Integer OCC3277 (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
 972 {
 973   if( argc != 2)
 974   {
 975     di << "Usage : " << argv[0] << " string" << "\n";
 976     return 1;
 977   }
 978   TCollection_ExtendedString ExtendedString;
 979   TCollection_ExtendedString InputString(argv[1]);
 980   ExtendedString.Cat(InputString);
 981   //ExtendedString.Print(cout);
 982   Standard_SStream aSStream;
 983   ExtendedString.Print(aSStream);
 984   di << aSStream;
 985   return 0;
 986 }
 987
 988 static Standard_Integer OCC6794 (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
 989 {
 990   if (argc > 2)
 991     {
 992       di << "Usage: " << argv[0] << " [nb]" << "\n";
 993       return 1;
 994     }
 995
 996   char* max = ::getenv( "MMGT_THRESHOLD" );
 997
 998   Standard_Integer aNb = 1;
 999   if ( max )
1000     aNb += Draw::Atoi( max );
1001   else
1002     aNb += 40000;
1003
1004   if ( argc > 1 )
1005     aNb = Draw::Atoi( argv[1] );
1006
1007   di << "Use nb = " << aNb << "\n";
1008
1009   const char* c = "a";
1010   {
1011     TCollection_AsciiString anAscii;
1012     for ( int i = 1; i <= aNb; i++ ) {
1013       anAscii += TCollection_AsciiString( c );
1014     }
1015     Standard_Integer aLength = anAscii.Length();
1016     di << "aLength = " << aLength << "\n";
1017   }
1018   return 0;
1019 }
1020
1021 static Standard_Integer OCC16485 (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
1022 {
1023   if (argc > 1)
1024     {
1025       di << "Usage: " << argv[0] << "\n";
1026       return 1;
1027     }
1028
1029   // Create points with X co-ordinate from varying from 0. to 1000.
1030   // anc compute cumulative bounding box by adding boxes for all the
1031   // points, enlarged on tolerance
1032
1033   Standard_Real tol = 1e-3;
1034   int nbstep = 1000;
1035   Bnd_Box Box;
1036   for ( int i=0; i <= nbstep; i++ )
1037   {
1038     gp_Pnt p(i, 0., 0.);
1039     Bnd_Box B;
1040     B.Add(p);
1041     B.Enlarge(tol);
1042     B.Add ( Box );
1043     Box = B; // in this case XMin of Box will grow each time
1044   }
1045
1046   Standard_Real xmin, ymin, zmin, xmax, ymax, zmax;
1047   Box.Get (xmin, ymin, zmin, xmax, ymax, zmax);
1048   //cout.precision(16);
1049   //cout << "Resulting dimensions: Xmin = " << xmin << " , Xmax = " << xmax << " , Tolerance = " << tol << endl;
1050   di << "Resulting dimensions: Xmin = " << xmin << " , Xmax = " << xmax << " , Tolerance = " << tol << "\n";
1051   if ( Abs ( xmin + tol ) > 1e-10 )
1052       di << "TEST FAILED: Xmin must be equal to -1e3!\n";
1053   else
1054       di << "TEST OK\n";
1055       //cout << "TEST FAILED: Xmin must be equal to -1e3!" << endl;
1056       //cout << "TEST OK" << endl;
1057       //di << "TEST FAILED: Xmin must be equal to -1e3!\n";
1058       //di << "TEST OK\n";
1059   return 0;
1060 }
1061 //Resulting dimensions: Xmin = -0.001 , Xmax = 1000.001 , Tolerance = 0.001
1062 //TEST OK
1063
1064 void QABugs::Commands_14(Draw_Interpretor& theCommands) {
1065   const char *group = "QABugs";
1066
1067   theCommands.Add ("BUC60897", "BUC60897", __FILE__, BUC60897, group);
1068   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);
1069   theCommands.Add ("BUC60852", "BUC60852 name_of_edge bndbox_X1 bndbox_Y1 bndbox_Z1 bndbox_X2 bndbox_Y2 bndbox_Z2", __FILE__, BUC60852, group);
1070   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 ... ] ] ", __FILE__, BUC60854, group);
1071   theCommands.Add ("BUC60870", "BUC60870 result name_of_shape_1 name_of_shape_2 dev", __FILE__, BUC60870, group);
1072   theCommands.Add ("BUC60902", "BUC60902", __FILE__, BUC60902, group);
1073   theCommands.Add ("BUC60944", "BUC60944 path", __FILE__, BUC60944, group);
1074   theCommands.Add ("BUC60868", "BUC60868 Result Shell", __FILE__, BUC60868, group);
1075   theCommands.Add ("BUC60924", "BUC60924 curve X Y Z", __FILE__, BUC60924, group);
1076   theCommands.Add ("BUC60920", "BUC60920", __FILE__, BUC60920, group);
1077   theCommands.Add ("OCC983", "OCC983 file", __FILE__, OCC983, group);
1078   theCommands.Add ("OCC984", "OCC984 file", __FILE__, OCC984, group);
1079
1080   theCommands.Add ("OCC1786", "OCC1786 AutoHilight=0/1", __FILE__, OCC1786, group);
1081
1082 //  theCommands.Add ("OCC1723", "OCC1723", __FILE__, OCC1723, group);
1083
1084   theCommands.Add ("OCC1919_get", "OCC1919_get", __FILE__, OCC1919_get, group);
1085
1086   theCommands.Add ("OCC1919_set", "OCC1919_set LC_NUMERIC", __FILE__, OCC1919_set, group);
1087
1088   theCommands.Add ("OCC1919_real", "OCC1919_real (DF, entry, value)", __FILE__, OCC1919_real, group);
1089
1090   theCommands.Add ("OCC2932_SetIDUAttribute", "OCC2932_SetIDUAttribute (DF, entry, oldLocalID, newLocalID)", __FILE__, OCC2932_SetIDUAttribute, group);
1091
1092   theCommands.Add ("OCC2932_SetTag", "OCC2932_SetTag (DF, entry, Tag)", __FILE__, OCC2932_SetTag, group);
1093
1094   theCommands.Add ("OCC2932_SetCurrent", "OCC2932_SetCurrent (DF, entry)", __FILE__, OCC2932_SetCurrent, group);
1095
1096   theCommands.Add ("OCC2932_SetExpression", "OCC2932_SetExpression (DF, entry, Expression)", __FILE__, OCC2932_SetExpression, group);
1097
1098   theCommands.Add ("OCC2932_SetRelation", "OCC2932_SetRelation (DF, entry, Relation)", __FILE__, OCC2932_SetRelation, group);
1099
1100   theCommands.Add ("OCC3277", "OCC3277 string", __FILE__, OCC3277, group);
1101
1102   theCommands.Add ("OCC6794", "OCC6794 [nb]", __FILE__, OCC6794, group);
1103
1104   theCommands.Add ("OCC16485", "OCC16485", __FILE__, OCC16485, group);
1105
1106   return;
1107 }