0029967: Draw Harness - command bounding has annoying syntax
[occt.git] / src / BRepTest / BRepTest_BasicCommands.cxx
1 // Created on: 1994-12-13
2 // Created by: Jacques GOUSSARD
3 // Copyright (c) 1994-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17 #include <Standard_Stream.hxx>
18 #include <Standard_Macro.hxx>
19
20 #include <BRepTest.hxx>
21
22 #include <DBRep.hxx>
23 #include <Draw_Appli.hxx>
24 #include <Draw_Interpretor.hxx>
25 #include <Draw_Box.hxx>
26
27 #include <BRepBuilderAPI.hxx>
28 #include <BRepBuilderAPI_FindPlane.hxx>
29 #include <BRepBuilderAPI_Copy.hxx>
30 #include <BRepBuilderAPI_Transform.hxx>
31 #include <BRepBuilderAPI_GTransform.hxx>
32 #include <BRepBuilderAPI_NurbsConvert.hxx>
33 #include <gp_Ax2.hxx>
34 #include <gp_Mat.hxx>
35 #include <gp_GTrsf.hxx>
36 #include <BRepOffsetAPI_NormalProjection.hxx>
37 #include <BRepLib.hxx>
38 #include <BRep_Builder.hxx>
39 #include <BRepBndLib.hxx>
40 #include <Bnd_Box.hxx>
41 #include <Bnd_Box2d.hxx>
42 #include <TopExp_Explorer.hxx>
43 #include <TopoDS.hxx>
44 #include <BRepTools_WireExplorer.hxx>
45
46 #include <GCPnts_QuasiUniformAbscissa.hxx>
47 #include <Geom2dAdaptor_Curve.hxx>
48 #include <GeomAdaptor_Curve.hxx>
49 #include <ProjLib_ComputeApproxOnPolarSurface.hxx>
50 #include <DrawTrSurf.hxx>
51 #include <Geom_Plane.hxx>
52
53 #include <OSD_Timer.hxx>
54 #include <Draw_Segment3D.hxx>
55 #include <Draw_Marker3D.hxx>
56 #include <Draw_MarkerShape.hxx>
57 #include <BRepPrimAPI_MakeBox.hxx>
58 #include <stdio.h>
59
60 Standard_IMPORT Draw_Viewer dout;
61
62 //=======================================================================
63 //function : ConvertBndToShape
64 //purpose  : Creates TopoDS_Solid from theBox
65 //=======================================================================
66 static void ConvertBndToShape(const Bnd_OBB& theBox,
67                               const char* const theName)
68 {
69   if (theBox.IsVoid())
70   {
71     DBRep::Set (theName, TopoDS_Shape());
72     return;
73   }
74
75   const gp_Pnt &aBaryCenter = theBox.Center();
76   const gp_XYZ &aXDir = theBox.XDirection(),
77                &aYDir = theBox.YDirection(),
78                &aZDir = theBox.ZDirection();
79   Standard_Real aHalfX = theBox.XHSize(),
80                 aHalfY = theBox.YHSize(),
81                 aHalfZ = theBox.ZHSize();
82
83   gp_Ax2 anAxes(aBaryCenter, aZDir, aXDir);
84   anAxes.SetLocation(aBaryCenter.XYZ() - aHalfX*aXDir - aHalfY*aYDir - aHalfZ*aZDir);
85   TopoDS_Solid aBox = BRepPrimAPI_MakeBox(anAxes, 2.0*aHalfX, 2.0*aHalfY, 2.0*aHalfZ);
86   DBRep::Set(theName, aBox);
87 }
88
89 //=======================================================================
90 // addpcurve
91 //=======================================================================
92
93 static Standard_Integer addpcurve(Draw_Interpretor& , Standard_Integer n, const char** a)
94 {
95   if(n < 4) return 1;
96   TopoDS_Shape E = DBRep::Get(a[1]);
97   if (E.IsNull()) return 1;
98   Handle(Geom2d_Curve) PC = DrawTrSurf::GetCurve2d(a[2]);
99   TopoDS_Shape F = DBRep::Get(a[3]);
100   Standard_Real tol = 1.e-7;
101   if (n > 4) {
102     tol = Draw::Atof(a[4]);
103   }
104   BRep_Builder BB;
105   BB.UpdateEdge(TopoDS::Edge(E), PC, TopoDS::Face(F),tol); 
106   DBRep::Set(a[1], E);
107   return 0;
108 }
109
110
111 //=======================================================================
112 // transform
113 //=======================================================================
114
115 static Standard_Integer transform(Draw_Interpretor& ,Standard_Integer n,const char** a)
116 {
117   if (n <= 1) return 1;
118
119   gp_Trsf T;
120   Standard_Integer last = n;
121   const char* aName = a[0];
122
123   Standard_Boolean isBasic = Standard_False;
124   Standard_Boolean isCopy = Standard_False;
125
126   // Check "copy" flag.
127   if (!strcmp(a[n-1], "-copy")) {
128     isCopy = Standard_True;
129     last = --n;
130   }
131
132   if (!strcmp(aName,"reset")) {
133   }
134   else {
135     isBasic = (aName[0] == 'b');
136     aName++;
137
138     if (!strcmp(aName,"move")) {
139       if (n < 3) return 1;
140       TopoDS_Shape SL = DBRep::Get(a[n-1]);
141       if (SL.IsNull()) return 0;
142       T = SL.Location().Transformation();
143       last = n-1;
144     }
145     else if (!strcmp(aName,"translate")) {
146       if (n < 5) return 1;
147       T.SetTranslation(gp_Vec(Draw::Atof(a[n-3]),Draw::Atof(a[n-2]),Draw::Atof(a[n-1])));
148       last = n-3;
149     }
150     else if (!strcmp(aName,"rotate")) {
151       if (n < 9) return 1;
152       T.SetRotation(gp_Ax1(gp_Pnt(Draw::Atof(a[n-7]),Draw::Atof(a[n-6]),Draw::Atof(a[n-5])),
153                     gp_Vec(Draw::Atof(a[n-4]),Draw::Atof(a[n-3]),Draw::Atof(a[n-2]))),
154                     Draw::Atof(a[n-1])* (M_PI / 180.0));
155       last = n-7;
156     }
157     else if (!strcmp(aName,"mirror")) {
158       if (n < 8) return 1;
159       T.SetMirror(gp_Ax2(gp_Pnt(Draw::Atof(a[n-6]),Draw::Atof(a[n-5]),Draw::Atof(a[n-4])),
160                   gp_Vec(Draw::Atof(a[n-3]),Draw::Atof(a[n-2]),Draw::Atof(a[n-1]))));
161       last = n-6;
162     }
163     else if (!strcmp(aName,"scale")) {
164       if (n < 6) return 1;
165       T.SetScale(gp_Pnt(Draw::Atof(a[n-4]),Draw::Atof(a[n-3]),Draw::Atof(a[n-2])),Draw::Atof(a[n-1]));
166       last = n-4;
167     }
168   }
169
170   if (T.Form() == gp_Identity || isBasic) {
171     TopLoc_Location L(T);
172     for (Standard_Integer i = 1; i < last; i++) {
173       TopoDS_Shape S = DBRep::Get(a[i]);
174       if (S.IsNull())
175       {
176         std::cerr << "Error: " << a[i] << " is not a valid shape\n";
177         return 1;
178       }
179       else
180         DBRep::Set(a[i],S.Located(L));
181     }
182   }
183   else {
184     BRepBuilderAPI_Transform trf(T);
185     for (Standard_Integer i = 1; i < last; i++) {
186       TopoDS_Shape S = DBRep::Get(a[i]);
187       if (S.IsNull()) {
188         std::cerr << "Error: " << a[i] << " is not a valid shape\n";
189         return 1;
190       }
191       else {
192         trf.Perform(S, isCopy);
193         if (!trf.IsDone())
194           return 1;
195         DBRep::Set(a[i],trf.Shape());
196       }
197     }
198   }
199   return 0;
200 }
201
202 ///=======================================================================
203 // gtransform
204 //=======================================================================
205
206 static Standard_Integer deform(Draw_Interpretor& di,Standard_Integer n,const char** a)
207 {
208   if (n <= 1) return 1;
209   
210   Standard_Integer last = n;
211   
212   gp_Trsf T;
213   gp_GTrsf GT(T);
214   
215 //  gp_Mat rot(Draw::Atof(a[last-3]),0,0,0,Draw::Atof(a[last-2]),0,0,0,Draw::Atof(a[last-1]));
216   gp_Mat rot(Draw::Atof(a[3]),0,0,0,Draw::Atof(a[4]),0,0,0,Draw::Atof(a[5]));
217   GT.SetVectorialPart(rot);
218   last -= 3;
219   BRepBuilderAPI_GTransform gtrf(GT);
220   BRepBuilderAPI_NurbsConvert nbscv;
221   //  for (Standard_Integer i = 1; i < last; i++) {
222   //    TopoDS_Shape S = DBRep::Get(a[i]);
223   TopoDS_Shape S = DBRep::Get(a[2]);    
224   if (S.IsNull()) {
225     //cout << a[2] << " is not a valid shape" << endl;
226     di << a[2] << " is not a valid shape\n";
227   }
228   else {
229     gtrf.Perform(S);
230     if (gtrf.IsDone()){
231       DBRep::Set(a[1],gtrf.Shape());
232     }
233     else {
234       return 1;
235     }
236   }
237   
238   return 0;
239 }
240
241 //=======================================================================
242 // tcopy
243 //=======================================================================
244
245 static Standard_Integer tcopy(Draw_Interpretor& di,Standard_Integer n,const char** a)
246 {
247   Standard_Boolean copyGeom = Standard_True;
248   Standard_Boolean copyMesh = Standard_False;
249   Standard_Integer iFirst = 1; // index of first shape argument
250
251   if (n > 1)
252   {
253     for (Standard_Integer i = 1; i <= 2; i++)
254     {
255       if (a[i][0] != '-')
256         break;
257       if (a[i][1] == 'n')
258       {
259         copyGeom = Standard_False;
260         iFirst++;
261       }
262       else if (a[i][1] == 'm')
263       {
264         copyMesh = Standard_True;
265         iFirst++;
266       }
267     }
268   }
269
270   if (n < 3 || (n - iFirst) % 2) {
271     cout << "Use: " << a[0] << " [-n(ogeom)] [-m(esh)] shape1 copy1 [shape2 copy2 [...]]" << endl;
272     cout << "Option -n forbids copying of geometry (it will be shared)" << endl;
273     cout << "Option -m forces copying of mesh (disabled by default)" << endl;
274     return 1;
275   }
276
277   BRepBuilderAPI_Copy cop;
278   Standard_Integer nbPairs = (n - iFirst) / 2;
279   for (Standard_Integer i=0; i < nbPairs; i++) {
280     cop.Perform(DBRep::Get(a[i+iFirst]), copyGeom, copyMesh);
281     DBRep::Set(a[i+iFirst+1],cop.Shape());
282     di << a[i+iFirst+1] << " ";
283   }
284   return 0;
285 }
286
287
288 //=======================================================================
289 // NurbsConvert
290 //=======================================================================
291
292 static Standard_Integer nurbsconvert(Draw_Interpretor& di,Standard_Integer n,const char** a)
293 {
294   if (n < 3) return 1;
295   if ((n-1)%2 != 0) return 1;
296   BRepBuilderAPI_NurbsConvert nbscv;
297   for (Standard_Integer i=0; i<(n-1)/2; i++) {
298     TopoDS_Shape S = DBRep::Get(a[2*i+2]);
299     if (S.IsNull()) {
300       //cout << a[2*i+2] << " is not a valid shape" << endl;
301       di << a[2*i+2] << " is not a valid shape\n";
302     }
303     else {
304       nbscv.Perform(S);
305       if (nbscv.IsDone()){
306         DBRep::Set(a[2*i+1],nbscv.Shape());
307       }
308       else {
309         return 1;
310       }
311     }
312   }
313   
314   return 0;
315   
316 }
317
318 //=======================================================================
319 // make a 3D edge curve
320 //=======================================================================
321
322 static Standard_Integer mkedgecurve (Draw_Interpretor& ,Standard_Integer n,const char** a)
323 {
324
325   if (n < 3) return 1;
326   Standard_Real Tolerance = Draw::Atof(a[2]) ;
327
328   TopoDS_Shape S = DBRep::Get(a[1]);
329   
330   if (S.IsNull()) return 1;
331   
332    BRepLib::BuildCurves3d(S,
333                           Tolerance) ;
334    return 0 ;
335 }
336
337 //=======================================================================
338 // sameparameter
339 //=======================================================================
340
341 static Standard_Integer sameparameter(Draw_Interpretor& di,Standard_Integer n,const char** a)
342 {
343   if (n < 2) 
344   {
345     di << "Use sameparameter [result] shape [toler]\n";
346     di << "shape is an initial shape\n";
347     di << "result is a result shape. if skipped = > initial shape will be modified\n";
348     di << "toler is tolerance (default is 1.e-7)";
349     return 1;
350   }
351   Standard_Real aTol = 1.e-7;
352   Standard_Boolean force  = !strcmp(a[0],"fsameparameter");
353
354   Standard_Real aTol1 = Draw::Atof(a[n-1]);
355   Standard_Boolean IsUseTol = aTol1>0;
356   if (IsUseTol)
357     aTol = aTol1;
358
359   TopoDS_Shape anInpS = DBRep::Get(IsUseTol ? a[n-2] : a[n-1]);
360   if (anInpS.IsNull())
361     return 1;
362
363   if ((n == 4 && IsUseTol) || (n == 3 && !IsUseTol))
364   {
365     TopoDS_Shape aResultSh;
366     BRepTools_ReShape aResh;
367     BRepLib::SameParameter(anInpS,aResh,aTol,force);
368     aResultSh = aResh.Apply(anInpS);
369     DBRep::Set(a[1],aResultSh); 
370   }
371   else
372   {
373     BRepLib::SameParameter(anInpS,aTol,force);
374     DBRep::Set(a[1],anInpS); 
375   }
376
377   return 0;
378 }
379 //=======================================================================
380 //function : updatetol
381 //purpose  : 
382 //=======================================================================
383 static Standard_Integer updatetol(Draw_Interpretor& di,Standard_Integer n,const char** a)
384 {
385   if (n < 2) 
386   {
387     di << "Use updatetololerance [result] shape [param]\n";
388     di << "shape is an initial shape\n";
389     di << "result is a result shape. if skipped = > initial shape will be modified\n";
390     di << "if [param] is absent - not verify of face tolerance, else - perform it";
391     return 1;
392   }
393   TopoDS_Shape aSh1 = DBRep::Get(a[n-1]);
394   Standard_Boolean IsF = aSh1.IsNull();
395
396   TopoDS_Shape anInpS = IsF ? DBRep::Get(a[n-2]) : aSh1;
397   if (anInpS.IsNull())
398     return 1;
399
400   if ((n == 4 && IsF) || (n == 3 && !IsF))
401   {
402     TopoDS_Shape aResultSh;
403     BRepTools_ReShape aResh;
404     BRepLib::UpdateTolerances(anInpS,aResh, IsF);
405     aResultSh = aResh.Apply(anInpS);
406     DBRep::Set(a[1],aResultSh); 
407   }
408   else
409   {
410     BRepLib::UpdateTolerances(anInpS, IsF);
411     DBRep::Set(a[1],anInpS); 
412   }
413
414   return 0;
415 }
416
417 //=======================================================================
418 //function : OrienSolid
419 //purpose  : 
420 //=======================================================================
421 static Standard_Integer orientsolid(Draw_Interpretor& ,Standard_Integer n,const char** a)
422 {
423   if (n < 2) return 1;
424
425   TopoDS_Shape S = DBRep::Get(a[1]);
426   if (S.IsNull()) return 1;
427   if (S.ShapeType()!=TopAbs_SOLID) return 1;
428
429   BRepLib::OrientClosedSolid(TopoDS::Solid(S));
430
431   DBRep::Set(a[1],S);
432   return 0;
433
434 }
435
436 //=======================================================================
437 //function : getcoords
438 //purpose  : 
439 //=======================================================================
440 static Standard_Integer getcoords(Draw_Interpretor& di,Standard_Integer n,const char** a)
441 {
442   if(n < 2) 
443     return 1;
444
445   for (Standard_Integer i = 1; i < n; i++) 
446   {
447     const TopoDS_Shape aShape = DBRep::Get (a[i]);
448
449     if (aShape.IsNull())
450       continue;
451
452     if (aShape.ShapeType() == TopAbs_VERTEX)
453     {
454       const TopoDS_Vertex& aVertex = TopoDS::Vertex(aShape);
455       gp_Pnt aPnt = BRep_Tool::Pnt(aVertex);
456
457       di << a[i] << " (x,y,z) : " << aPnt.X() << " " << aPnt.Y() << " " << aPnt.Z() << "\n";
458     }
459   }
460
461   return 0;
462 }
463
464 //! Parse 6 real values for defining AABB.
465 static Standard_Boolean parseMinMax (const char** theArgVec, Bnd_Box& theBox)
466 {
467   const TCollection_AsciiString aMin[3] = { theArgVec[0], theArgVec[1], theArgVec[2] };
468   const TCollection_AsciiString aMax[3] = { theArgVec[3], theArgVec[4], theArgVec[5] };
469   if (!aMin[0].IsRealValue()
470    || !aMin[1].IsRealValue()
471    || !aMin[2].IsRealValue()
472    || !aMax[0].IsRealValue()
473    || !aMax[1].IsRealValue()
474    || !aMax[2].IsRealValue())
475   {
476     return Standard_False;
477   }
478
479   const gp_Pnt aPntMin (aMin[0].RealValue(), aMin[1].RealValue(), aMin[2].RealValue());
480   const gp_Pnt aPntMax (aMax[0].RealValue(), aMax[1].RealValue(), aMax[2].RealValue());
481   theBox.SetVoid();
482   theBox.Add (aPntMin);
483   theBox.Add (aPntMax);
484   return Standard_True;
485 }
486
487 //=======================================================================
488 //function : BoundBox
489 //purpose  : 
490 //=======================================================================
491 static Standard_Integer BoundBox(Draw_Interpretor& theDI,
492                                  Standard_Integer theNArg,
493                                  const char** theArgVal)
494 {
495   // 1. Parse arguments
496
497   TopoDS_Shape aShape;
498   Bnd_Box anAABB;
499
500   Standard_Boolean doPrint = Standard_False;
501   Standard_Boolean useOldSyntax = Standard_False;
502   Standard_Boolean isOBB = Standard_False;
503   Standard_Boolean isTriangulationReq = Standard_True;
504   Standard_Boolean isOptimal = Standard_False;
505   Standard_Boolean isTolerUsed = Standard_False;
506   Standard_Boolean hasToDraw = Standard_True;
507   
508   TCollection_AsciiString anOutVars[6];
509   TCollection_AsciiString aResShapeName;
510   for (Standard_Integer anArgIter = 1; anArgIter < theNArg; ++anArgIter)
511   {
512     TCollection_AsciiString anArgCase (theArgVal[anArgIter]);
513     anArgCase.LowerCase();
514     if (anArgCase == "-obb")
515     {
516       isOBB = Standard_True;
517     }
518     else if (anArgCase == "-aabb")
519     {
520       isOBB = Standard_False;
521     }
522     else if (anArgCase == "-shape"
523           && anArgIter + 1 < theNArg
524           && aResShapeName.IsEmpty())
525     {
526       aResShapeName = theArgVal[++anArgIter];
527       hasToDraw = Standard_False;
528     }
529     else if (anArgCase == "-dump"
530           || anArgCase == "-print")
531     {
532       doPrint = Standard_True;
533     }
534     else if (anArgCase == "-save"
535           && anArgIter + 6 < theNArg
536           && anOutVars[0].IsEmpty())
537     {
538       for (int aCompIter = 0; aCompIter < 6; ++aCompIter)
539       {
540         anOutVars[aCompIter] = theArgVal[anArgIter + aCompIter + 1];
541       }
542       anArgIter += 6;
543     }
544     else if (anArgCase == "-notriangulation")
545     {
546       isTriangulationReq = Standard_False;
547     }
548     else if (anArgCase == "-optimal")
549     {
550       isOptimal = Standard_True;
551     }
552     else if (anArgCase == "-exttoler")
553     {
554       isTolerUsed = Standard_True;
555     }
556     else if (anArgCase == "-nodraw")
557     {
558       hasToDraw = Standard_False;
559     }
560     else if (aShape.IsNull()
561          && !DBRep::Get (theArgVal[anArgIter]).IsNull())
562     {
563       aShape = DBRep::Get (theArgVal[anArgIter]);
564     }
565     else if (anAABB.IsVoid()
566           && anArgIter + 5 < theNArg
567           && parseMinMax (theArgVal + anArgIter, anAABB))
568     {
569       anArgIter += 5;
570     }
571     else
572     {
573       std::cout << "Syntax error at argument '" << theArgVal[anArgIter] << "'.\n";
574       return 1;
575     }
576   }
577
578   if (anAABB.IsVoid()
579    && aShape.IsNull())
580   {
581     std::cout << "Syntax error: input is not specified (neither shape nor coordinates)\n";
582     return 1;
583   }
584   else if (!anAABB.IsVoid()
585         && (isOBB || isOptimal || isTolerUsed))
586   {
587     std::cout << "Syntax error: Options -obb, -optimal and -extToler cannot be used for explicitly defined AABB.\n";
588     return 1;
589   }
590   else if (isOBB
591        && !anOutVars[0].IsEmpty())
592   {
593     std::cout << "Error: Option -save works only with axes-aligned boxes.\n";
594     return 1;
595   }
596
597   // enable printing (old syntax) if neither saving to shape nor to DRAW variables is requested
598   if (! doPrint && anOutVars[0].IsEmpty() && aResShapeName.IsEmpty())
599   {
600     doPrint = Standard_True;
601     useOldSyntax = Standard_True;
602   }
603
604   // 2. Compute box and save results
605   Handle(Draw_Box) aDB;
606   if (isOBB)
607   {
608     Bnd_OBB anOBB;
609     BRepBndLib::AddOBB(aShape, anOBB, isTriangulationReq, isOptimal, isTolerUsed);
610
611     if (anOBB.IsVoid())
612     {
613       theDI << "Void box.\n";
614     }
615     else if (doPrint)
616     {
617       const gp_Pnt &aBaryCenter= anOBB.Center();
618       const gp_XYZ &aXDir = anOBB.XDirection(),
619                    &aYDir = anOBB.YDirection(),
620                    &aZDir = anOBB.ZDirection();
621       theDI << "Oriented bounding box\n";
622       theDI << "Center: " << aBaryCenter.X() << " " << 
623                              aBaryCenter.Y() << " " <<
624                              aBaryCenter.Z() << "\n";
625       theDI << "X-axis: " << aXDir.X() << " " << aXDir.Y() << " " << aXDir.Z() << "\n";
626       theDI << "Y-axis: " << aYDir.X() << " " << aYDir.Y() << " " << aYDir.Z() << "\n";
627       theDI << "Z-axis: " << aZDir.X() << " " << aZDir.Y() << " " << aZDir.Z() << "\n";
628       theDI << "Half X: " << anOBB.XHSize() << "\n"
629             << "Half Y: " << anOBB.YHSize() << "\n"
630             << "Half Z: " << anOBB.ZHSize() << "\n";
631     }
632
633     if (hasToDraw
634     && !anOBB.IsVoid())
635     {
636       aDB = new Draw_Box (anOBB, Draw_orange);
637     }
638
639     if (!aResShapeName.IsEmpty())
640     {
641       ConvertBndToShape (anOBB, aResShapeName.ToCString());
642     }
643   }
644   else // if(!isOBB)
645   {
646     if (!aShape.IsNull())
647     {
648       anAABB.SetVoid ();
649       if(isOptimal)
650       {
651         BRepBndLib::AddOptimal (aShape, anAABB, isTriangulationReq, isTolerUsed);
652       }
653       else
654       {
655         BRepBndLib::Add (aShape, anAABB, isTriangulationReq);
656       }
657     }
658
659     if (anAABB.IsVoid())
660     {
661       theDI << "Void box.\n";
662     }
663     else
664     {
665       const gp_Pnt aMin = anAABB.CornerMin();
666       const gp_Pnt aMax = anAABB.CornerMax();
667
668       // print to DRAW
669       if (doPrint)
670       {
671         if (useOldSyntax)
672         {
673           theDI << aMin.X () << " " << aMin.Y () << " " << aMin.Z () << " "
674                 << aMax.X () << " " << aMax.Y () << " " << aMax.Z () << "\n";
675         }
676         else
677         {
678           theDI << "Axes-aligned bounding box\n";
679           theDI << "X-range: " << aMin.X () << " " << aMax.X () << "\n" <<
680                    "Y-range: " << aMin.Y() << " " << aMax.Y() << "\n" <<
681                    "Z-range: " << aMin.Z () << " " << aMax.Z () << "\n";
682         }
683       }
684
685       // save DRAW variables
686       if (!anOutVars[0].IsEmpty())
687       {
688         Draw::Set (anOutVars[0].ToCString(), aMin.X());
689         Draw::Set (anOutVars[1].ToCString(), aMin.Y());
690         Draw::Set (anOutVars[2].ToCString(), aMin.Z());
691         Draw::Set (anOutVars[3].ToCString(), aMax.X());
692         Draw::Set (anOutVars[4].ToCString(), aMax.Y());
693         Draw::Set (anOutVars[5].ToCString(), aMax.Z());
694       }
695
696       // add presentation to DRAW viewer
697       if (hasToDraw)
698       {
699         aDB = new Draw_Box (anAABB, Draw_orange);
700       }
701     }
702
703     // save as shape
704     if (!aResShapeName.IsEmpty())
705     {
706       ConvertBndToShape (anAABB, aResShapeName.ToCString());
707     }
708   }
709
710   if (!aDB.IsNull())
711   {
712     dout << aDB;
713   }
714   return 0;
715 }
716
717 //=======================================================================
718 //function : IsBoxesInterfered
719 //purpose  : 
720 //=======================================================================
721 static Standard_Integer IsBoxesInterfered(Draw_Interpretor& theDI,
722                                           Standard_Integer theNArg,
723                                           const char** theArgVal)
724 {
725   if(theNArg < 2)
726   {
727     theDI << "Use: isbbinterf shape1 shape2 [-o].\n";
728     return 1;
729   }
730
731   const TopoDS_Shape aShape1 = DBRep::Get(theArgVal[1]);
732   const TopoDS_Shape aShape2 = DBRep::Get(theArgVal[2]);
733
734   Standard_Boolean isOBB = (theNArg > 3) && (!strcmp(theArgVal[3], "-o"));
735
736   if(isOBB)
737   {
738     Bnd_OBB anOBB1, anOBB2;
739     BRepBndLib::AddOBB(aShape1, anOBB1);
740     BRepBndLib::AddOBB(aShape2, anOBB2);
741
742     if(anOBB1.IsOut(anOBB2))
743     {
744       theDI << "The shapes are NOT interfered by OBB.\n";
745     }
746     else
747     {
748       theDI << "The shapes are interfered by OBB.\n";
749     }
750   }
751   else
752   {
753     Bnd_Box anAABB1, anAABB2;
754     BRepBndLib::Add(aShape1, anAABB1);
755     BRepBndLib::Add(aShape2, anAABB2);
756
757     if(anAABB1.IsOut(anAABB2))
758     {
759       theDI << "The shapes are NOT interfered by AABB.\n";
760     }
761     else
762     {
763       theDI << "The shapes are interfered by AABB.\n";
764     }
765   }
766
767   return 0;
768 }
769
770 //=======================================================================
771 //function : gbounding
772 //purpose  : 
773 //=======================================================================
774 #include <GeomAdaptor_Surface.hxx>
775 #include <BndLib_AddSurface.hxx>
776 #include <BndLib_Add3dCurve.hxx>
777 #include <BndLib_Add2dCurve.hxx>
778 #include <Draw_Segment2D.hxx>
779 static Standard_Integer gbounding(Draw_Interpretor& di,Standard_Integer n,const char** a)
780 {
781   if (n != 2 && n != 3) 
782   {
783     di << "Usage: gbounding surf/curve/curve2d [-o] \n";
784     di << "[-o] turn on Optimal mode ('off' by default) \n";
785     return 1;
786   }
787   else
788   {
789     Standard_Boolean IsOptimal = Standard_False;
790     if (n == 3 && !strcmp(a[2], "-o"))
791       IsOptimal = Standard_True;
792     
793     Standard_Real axmin,aymin,azmin,axmax,aymax,azmax;
794     Bnd_Box B;
795     Bnd_Box2d B2d;
796     Handle(Draw_Box) DB;
797     Standard_Boolean Is3d = Standard_True;
798     Handle(Geom_Curve) C;
799     Handle(Geom_Surface) S;
800     Handle_Geom2d_Curve C2d;
801     S = DrawTrSurf::GetSurface(a[1]);
802     if (!S.IsNull())
803     {
804       //add surf
805       GeomAdaptor_Surface aGAS(S);
806       if (IsOptimal)
807         BndLib_AddSurface::AddOptimal(aGAS, Precision::Confusion(), B);
808       else
809         BndLib_AddSurface::Add(aGAS, Precision::Confusion(), B);
810     }
811     else
812     {
813       C = DrawTrSurf::GetCurve(a[1]);
814       if (!C.IsNull())
815       {
816         // add cur
817         GeomAdaptor_Curve aGAC(C);
818         if (IsOptimal)
819           BndLib_Add3dCurve::AddOptimal(aGAC, Precision::Confusion(), B);
820         else
821           BndLib_Add3dCurve::Add(aGAC, Precision::Confusion(), B);
822       }
823       else
824       {
825         C2d = DrawTrSurf::GetCurve2d(a[1]);
826         if (!C2d.IsNull())
827         {
828           //add cur2d
829           Is3d = Standard_False;
830           if (IsOptimal)
831             BndLib_Add2dCurve::AddOptimal(C2d, C2d->FirstParameter(), C2d->LastParameter(), Precision::Confusion(), B2d); 
832           else
833             BndLib_Add2dCurve::Add(C2d, C2d->FirstParameter(), C2d->LastParameter(), Precision::Confusion(), B2d); 
834         }
835         else
836         {
837           di << "Wrong argument \n";
838           return 1;
839         }
840       }
841     }
842
843     if (Is3d)
844     {
845       B.Get(axmin,aymin,azmin,axmax,aymax,azmax);
846       DB = new Draw_Box(B, Draw_vert);
847       dout<<DB;
848       di << axmin<<" "<< aymin<<" "<< azmin<<" "<< axmax<<" "<< aymax<<" "<< azmax;
849     }
850     else
851     {
852       B2d.Get(axmin,aymin,axmax,aymax);
853       gp_Pnt2d p1(axmin, aymin);
854       gp_Pnt2d p2(axmax, aymin);
855       gp_Pnt2d p3(axmax, aymax);
856       gp_Pnt2d p4(axmin, aymax);
857       Draw_Segment2D* S1 = new Draw_Segment2D(p1, p2, Draw_vert);
858       Draw_Segment2D* S2 = new Draw_Segment2D(p2, p3, Draw_vert);
859       Draw_Segment2D* S3 = new Draw_Segment2D(p3, p4, Draw_vert);
860       Draw_Segment2D* S4 = new Draw_Segment2D(p4, p1, Draw_vert);
861       dout << S1 << S2 << S3 << S4;
862       di << axmin<<" "<< aymin<<" "<< axmax<<" "<< aymax;
863     }
864   }
865   return 0;
866 }
867
868 //=======================================================================
869 //function : findplane
870 //purpose  : 
871 //=======================================================================
872 static Standard_Integer findplane(Draw_Interpretor& di,Standard_Integer n,const char** a)
873 {
874   if (n < 3) return 1;
875   TopoDS_Shape S = DBRep::Get(a[1]);
876   if (S.IsNull()) return 1;
877   Standard_Real tolerance = 1.0e-5 ;
878   BRepBuilderAPI_FindPlane a_plane_finder(S,
879                                    tolerance) ;
880   if (a_plane_finder.Found()) {
881     //cout << " a plane is found "   ;
882     di << " a plane is found \n";
883     const Handle(Geom_Geometry)& aSurf = a_plane_finder.Plane(); // to avoid ambiguity
884     DrawTrSurf::Set(a[2],aSurf) ;
885   }
886   return 0 ;
887 }
888 //=======================================================================
889 //function : precision
890 //purpose  : 
891 //=======================================================================
892
893 static Standard_Integer precision(Draw_Interpretor& di,Standard_Integer n,const char** a)
894 {
895   n--;
896
897   if ( n == 0) {
898     //cout << " Current Precision = " << BRepBuilderAPI::Precision() << endl;
899     di << " Current Precision = " << BRepBuilderAPI::Precision() << "\n";
900   }
901   else {
902     BRepBuilderAPI::Precision(Draw::Atof(a[1]));
903   }
904   return 0;
905 }
906
907
908 //=======================================================================
909 //function : reperage shape (Int lin Shape) + pointe double click   + maxtol
910 //purpose  : 
911 //=======================================================================
912 #include <IntCurvesFace_ShapeIntersector.hxx>
913 #include <gp_Lin.hxx>
914
915 static Standard_Integer reperageshape(Draw_Interpretor& di, Standard_Integer narg , const char** a) 
916 {
917   Standard_Integer details=0;
918   if(narg<2) return 1;
919   if(narg==3) details=1;
920   const char *id1 = a[1];
921   TopoDS_Shape TheShape1 = DBRep::Get(id1);
922   
923   //cout << "Pick positions with button "<<endl;
924   di << "Pick positions with button \n";
925   Standard_Integer id,X,Y,b;
926   gp_Trsf T;
927   gp_Pnt P1,P2;
928   dout.Select(id,X,Y,b);
929   
930   dout.GetTrsf(id,T);
931   T.Invert();
932   Standard_Real z = dout.Zoom(id);
933   P2.SetCoord((Standard_Real)X /z,(Standard_Real)Y /z, 0.0);
934   P2.Transform(T);
935   P1.SetCoord((Standard_Real)X /z,(Standard_Real)Y /z,-1.0);
936   P1.Transform(T);
937   
938   
939   gp_Ax1 Axe(P1,gp_Vec(P1,P2));
940   IntCurvesFace_ShapeIntersector Inter;
941   Inter.Load(TheShape1,1e-7);
942   
943   Inter.Perform(Axe,-RealLast(),RealLast());
944   
945   //cout<<"\n --> ";
946   di <<"\n --> ";
947   if(Inter.NbPnt()) { 
948     for(Standard_Integer i=1; i<=Inter.NbPnt(); i++) { 
949       Standard_Integer numface=1;
950       TopExp_Explorer ExF;
951       for(ExF.Init(TheShape1,TopAbs_FACE);
952           ExF.More();
953           ExF.Next(),numface++) { 
954         TopoDS_Face Face=TopoDS::Face(ExF.Current());
955         if(Face.IsEqual(Inter.Face(i))) { 
956           //cout<<" "<<a[1]<<"_"<<numface;
957           di<<" "<<a[1]<<"_"<<numface;
958           continue;       
959         }
960       }
961       const gp_Pnt& P = Inter.Pnt(i);
962       Standard_Real PMin = Inter.WParameter(i);
963       if(details) { 
964         //cout<<" w:"<<PMin<<endl;
965         di<<" w:"<<PMin<< "\n";
966       }
967       if(Inter.Transition(i) == IntCurveSurface_In) { 
968         if(Inter.State(i) == TopAbs_IN) { 
969           Handle(Draw_Marker3D) p = new Draw_Marker3D(P, Draw_Square, Draw_rouge,2); 
970           dout << p;   dout.Flush();
971         }
972         else if(Inter.State(i) == TopAbs_ON) { 
973           Handle(Draw_Marker3D) p = new Draw_Marker3D(P, Draw_Square, Draw_vert,2); 
974           dout << p;   dout.Flush();
975         }
976       }
977       else { 
978         if(Inter.Transition(i) == IntCurveSurface_Out) { 
979           if(Inter.State(i) == TopAbs_IN) { 
980             Handle(Draw_Marker3D) p = new Draw_Marker3D(P, Draw_X, Draw_rouge,2); 
981             dout << p;   dout.Flush();
982           }
983           else if(Inter.State(i) == TopAbs_ON) { 
984             Handle(Draw_Marker3D) p = new Draw_Marker3D(P, Draw_X, Draw_vert,2); 
985             dout << p;   dout.Flush();
986           }
987         } 
988       }
989     }
990   }
991   //cout<<endl;
992   di << "\n";
993   return(0);
994 }
995
996
997 static Standard_Integer maxtolerance(Draw_Interpretor& theCommands, 
998                                      Standard_Integer n, const char** a) { 
999   if(n<2) return(1);
1000   TopoDS_Shape TheShape = DBRep::Get(a[1]);
1001   if(TheShape.IsNull()) return(1);
1002
1003   Standard_Real T,TMF,TME,TMV,TmF,TmE,TmV;
1004   Standard_Integer nbF,nbE,nbV;
1005   TMF=TME=TMV=-RealLast();
1006   TmF=TmE=TmV=RealLast();
1007   
1008   TopTools_MapOfShape mapS;
1009   mapS.Clear();
1010
1011   for(TopExp_Explorer ex(TheShape,TopAbs_FACE);
1012       ex.More();
1013       ex.Next()) { 
1014     TopoDS_Face Face=TopoDS::Face(ex.Current());
1015     T=BRep_Tool::Tolerance(Face);
1016     if(T>TMF) TMF=T;
1017     if(T<TmF) TmF=T;
1018     mapS.Add(Face);
1019   }
1020   
1021   nbF = mapS.Extent();
1022   mapS.Clear();
1023   
1024   for(TopExp_Explorer ex(TheShape,TopAbs_EDGE);
1025       ex.More();
1026       ex.Next()) { 
1027     TopoDS_Edge Edge=TopoDS::Edge(ex.Current());
1028     T=BRep_Tool::Tolerance(Edge);
1029     if(T>TME) TME=T;
1030     if(T<TmE) TmE=T;
1031     mapS.Add(Edge);
1032   }
1033
1034   nbE = mapS.Extent();
1035   mapS.Clear();
1036
1037   for(TopExp_Explorer ex(TheShape,TopAbs_VERTEX);
1038       ex.More();
1039       ex.Next()) { 
1040     TopoDS_Vertex Vertex=TopoDS::Vertex(ex.Current());
1041     T=BRep_Tool::Tolerance(Vertex);
1042     if(T>TMV) TMV=T;
1043     if(T<TmV) TmV=T;
1044     mapS.Add(Vertex);
1045   }
1046
1047   nbV = mapS.Extent();
1048
1049   Standard_SStream sss;
1050   sss << "\n## Tolerances on the shape " << a[1] << "  (nbFaces:" << nbF
1051       << "  nbEdges:" << nbE << " nbVtx:" << nbV << ")\n" ;
1052   sss.precision(5);
1053   sss.setf(ios::scientific);
1054   if(TmF<=TMF) sss << "\n    Face   : Min " << setw(8) << TmF <<"    Max  " << setw(8) << TMF << " \n ";
1055   if(TmE<=TME) sss << "\n    Edge   : Min " << setw(8) << TmE <<"    Max  " << setw(8) << TME << " \n ";
1056   if(TmV<=TMV) sss << "\n    Vertex : Min " << setw(8) << TmV <<"    Max  " << setw(8) << TMV << " \n ";
1057   theCommands << sss;
1058
1059   return 0;
1060 }
1061
1062
1063 static Standard_Integer vecdc(Draw_Interpretor& di,Standard_Integer ,const char** ) {
1064   //cout << "Pick positions with button "<<endl;
1065   di << "Pick positions with button \n";
1066
1067   Standard_Integer id,X,Y,b;
1068   gp_Trsf T;
1069   gp_Pnt P1,P2,PP1,PP2;
1070   
1071   //-----------------------------------------------------------
1072   dout.Select(id,X,Y,b);    dout.GetTrsf(id,T);
1073   T.Invert();
1074   Standard_Real z = dout.Zoom(id);
1075   P1.SetCoord((Standard_Real)X /z,(Standard_Real)Y /z,0.0);
1076   P1.Transform(T);
1077   
1078   dout.Select(id,X,Y,b);  dout.GetTrsf(id,T);
1079   T.Invert();  z = dout.Zoom(id);
1080   
1081   P2.SetCoord((Standard_Real)X /z,(Standard_Real)Y /z,0.0);
1082   P2.Transform(T);
1083   Standard_Real xa,ya,za;
1084   if(Abs(P1.X())>Abs(P2.X())) xa = P1.X(); else xa = P2.X();
1085   if(Abs(P1.Y())>Abs(P2.Y())) ya = P1.Y(); else ya = P2.Y();
1086   if(Abs(P1.Z())>Abs(P2.Z())) za = P1.Z(); else za = P2.Z();
1087   P1.SetCoord(xa,ya,za);
1088   Handle(Draw_Marker3D) D0 = new Draw_Marker3D(gp_Pnt(P1.X(),
1089                                                       P1.Y(),
1090                                                       P1.Z()),
1091                                                Draw_Square,Draw_blanc,1);
1092   
1093   dout << D0;
1094   dout.Flush();
1095   //-----------------------------------------------------------
1096   dout.Select(id,X,Y,b);  
1097   dout.GetTrsf(id,T);
1098   T.Invert();
1099   z = dout.Zoom(id);
1100   PP1.SetCoord((Standard_Real)X /z,(Standard_Real)Y /z,0.0);
1101   PP1.Transform(T);
1102   dout.Select(id,X,Y,b);
1103   dout.GetTrsf(id,T);
1104   T.Invert();
1105   z = dout.Zoom(id);
1106   PP2.SetCoord((Standard_Real)X /z,(Standard_Real)Y /z,0.0);
1107   PP2.Transform(T);
1108   if(Abs(PP1.X())>Abs(PP2.X())) xa = PP1.X(); else xa = PP2.X();
1109   if(Abs(PP1.Y())>Abs(PP2.Y())) ya = PP1.Y(); else ya = PP2.Y();
1110   if(Abs(PP1.Z())>Abs(PP2.Z())) za = PP1.Z(); else za = PP2.Z();
1111   PP1.SetCoord(xa,ya,za);
1112   Handle(Draw_Segment3D) d = new Draw_Segment3D(P1,PP1,Draw_blanc);
1113   dout << d;
1114   dout.Flush();
1115   //cout<<"\nttran   "<<PP1.X()-P1.X()<<" "<<PP1.Y()-P1.Y()<<" "<<PP1.Z()-P1.Z()<<endl;
1116   di <<"\nttran   "<<PP1.X()-P1.X()<<" "<<PP1.Y()-P1.Y()<<" "<<PP1.Z()-P1.Z()<< "\n";
1117
1118   static Standard_Integer nboxvecdp=0;
1119   //cout<<"\nbox  b"<<++nboxvecdp<<" "<<Min(P1.X(),PP1.X())<<" "<<Min(P1.Y(),PP1.Y())<<" "<<Min(PP1.Z(),P1.Z());
1120   //cout<<"  "<<Abs(PP1.X()-P1.X())<<" "<<Abs(PP1.Y()-P1.Y())<<" "<<Abs(PP1.Z()-P1.Z())<<endl;
1121
1122   //cout<<"\nDistance :"<<sqrt( (PP1.X()-P1.X())*(PP1.X()-P1.X())
1123         //                   +(PP1.Y()-P1.Y())*(PP1.Y()-P1.Y())
1124         //                   +(PP1.Z()-P1.Z())*(PP1.Z()-P1.Z()))<<endl;
1125
1126   di <<"\nbox  b"<<++nboxvecdp<<" "<<Min(P1.X(),PP1.X())<<" "<<Min(P1.Y(),PP1.Y())<<" "<<Min(PP1.Z(),P1.Z());
1127   di <<"  "<<Abs(PP1.X()-P1.X())<<" "<<Abs(PP1.Y()-P1.Y())<<" "<<Abs(PP1.Z()-P1.Z())<< "\n";
1128
1129   di <<"\nDistance :"<<sqrt( (PP1.X()-P1.X())*(PP1.X()-P1.X())
1130                              +(PP1.Y()-P1.Y())*(PP1.Y()-P1.Y())
1131                              +(PP1.Z()-P1.Z())*(PP1.Z()-P1.Z()))<< "\n";
1132   return(0);
1133 }
1134 //=======================================================================
1135 // nproject
1136 //=======================================================================
1137
1138 #include <TopTools_SequenceOfShape.hxx>
1139  static Standard_Integer nproject(Draw_Interpretor& di, Standard_Integer n, const char** a)
1140 {
1141   if ( n < 4) return 1;
1142   TopoDS_Shape InpShape;
1143   Standard_Integer arg = 2, i;
1144   TopTools_SequenceOfShape Args; 
1145
1146   Standard_Real Tol = 1.e-4;        
1147   Standard_Real Tol2d;
1148   Standard_Real MaxDistance = 1.e-3;
1149   GeomAbs_Shape Continuity = GeomAbs_C2;  
1150   Standard_Integer MaxDeg = 14;           
1151   Standard_Integer MaxSeg = 16;           
1152
1153   while((n > arg) && !(InpShape = DBRep::Get(a[arg])).IsNull()){
1154     Args.Append(InpShape);
1155     arg++;
1156   }
1157   if(Args.Length() < 2) return 1;
1158   
1159   BRepOffsetAPI_NormalProjection OrtProj(Args.Last());
1160
1161   for(i = 1; i < Args.Length(); i++)
1162     OrtProj.Add(Args(i));
1163
1164   if(n > arg)
1165     if (!strcmp(a[arg],"-g")) {
1166       OrtProj.SetLimit(Standard_False);
1167       arg++;
1168     }
1169   
1170   if(n > arg)
1171     if (!strcmp(a[arg],"-d")) {
1172       arg++;
1173       if(n > arg)
1174         MaxDistance = Draw::Atof(a[arg++]);
1175       OrtProj.SetMaxDistance(MaxDistance);
1176     }
1177   if(n > arg) {
1178     Tol = Max(Draw::Atof(a[arg++]),1.e-10);
1179   }
1180
1181   if(n > arg) {
1182     if (Draw::Atoi(a[arg]) == 0) Continuity = GeomAbs_C0;
1183     else if (Draw::Atoi(a[arg]) == 1) Continuity = GeomAbs_C1;
1184     arg++;
1185   }
1186
1187  
1188   if(n > arg) {
1189     MaxDeg = Draw::Atoi(a[arg++]);
1190     if (MaxDeg<1 || MaxDeg>14) MaxDeg = 14;
1191   }
1192
1193   if(n > arg) MaxSeg = Draw::Atoi(a[arg]);
1194     
1195   Tol2d = Pow(Tol, 2./3);
1196
1197   OrtProj.SetParams(Tol, Tol2d, Continuity, MaxDeg, MaxSeg);
1198   OrtProj.Build();
1199   TopTools_ListOfShape Wire;
1200   Standard_Boolean IsWire=OrtProj.BuildWire(Wire);
1201   if (IsWire) {
1202     //cout << " BuildWire OK " << endl;
1203     di << " BuildWire OK \n";
1204   }
1205   DBRep::Set(a[1], OrtProj.Shape());
1206   return 0;  
1207 }
1208
1209 //==========================================================================
1210 //function : wexplo
1211 //           exploration of a wire 
1212 //==========================================================================
1213 static Standard_Integer wexplo (Draw_Interpretor&, 
1214                                 Standard_Integer argc, const char** argv)
1215
1216   char name[100];
1217   if (argc < 2) return 1;
1218   
1219   TopoDS_Shape C1 = DBRep::Get (argv[1],TopAbs_WIRE);
1220   TopoDS_Shape C2 ;
1221
1222   if (argc > 2)  C2 = DBRep::Get (argv[2],TopAbs_FACE);
1223
1224   if (C1.IsNull()) return 1;
1225
1226   BRepTools_WireExplorer we;
1227   if (C2.IsNull()) we.Init(TopoDS::Wire(C1));
1228   else             we.Init(TopoDS::Wire(C1),TopoDS::Face(C2));
1229
1230   Standard_Integer k = 1;
1231   while (we.More()) {
1232     TopoDS_Edge E = we.Current();
1233     Sprintf(name,"WEDGE_%d",k); 
1234           DBRep::Set(name,E);
1235     we.Next();
1236     k++;
1237   }
1238
1239   return 0;
1240 }
1241
1242 static Standard_Integer scalexyz(Draw_Interpretor& /*di*/, Standard_Integer n, const char** a)
1243 {
1244   if (n < 6) return 1;
1245
1246   TopoDS_Shape aShapeBase = DBRep::Get(a[2]);
1247   if (aShapeBase.IsNull()) return 1;
1248   
1249   Standard_Real aFactorX = Draw::Atof(a[3]);
1250   Standard_Real aFactorY = Draw::Atof(a[4]);
1251   Standard_Real aFactorZ = Draw::Atof(a[5]);
1252
1253   gp_GTrsf aGTrsf;
1254   gp_Mat rot (aFactorX, 0, 0,
1255               0, aFactorY, 0,
1256               0, 0, aFactorZ);
1257   aGTrsf.SetVectorialPart(rot);
1258   BRepBuilderAPI_GTransform aBRepGTrsf (aShapeBase, aGTrsf, Standard_False);
1259   if (!aBRepGTrsf.IsDone())
1260     throw Standard_ConstructionError("Scaling not done");
1261   TopoDS_Shape Result = aBRepGTrsf.Shape();
1262
1263   DBRep::Set(a[1], Result);
1264   return 0;  
1265 }
1266
1267 //=======================================================================
1268 //function : compareshapes
1269 //purpose  : 
1270 //=======================================================================
1271 static Standard_Integer compareshapes(Draw_Interpretor& di,
1272                                       Standard_Integer n,
1273                                       const char** a)
1274 {
1275   if (n != 3) {
1276     di << "Compare shapes. Usage: compare shape1 shape2\n";
1277     return 1;
1278   }
1279   // get shapes
1280   TopoDS_Shape aS1 = DBRep::Get(a[1]);
1281   TopoDS_Shape aS2 = DBRep::Get(a[2]);
1282   // check shapes
1283   if (aS1.IsNull() || aS2.IsNull()) {
1284     di << "null shapes\n";
1285     return 0;
1286   }
1287   // compare shapes
1288   if (aS1.IsSame(aS2)) {
1289     di << "same shapes\n";
1290     if (aS1.IsEqual(aS2)) {
1291       di << "equal shapes\n";
1292     }
1293   }
1294   else {
1295     di << "shapes are not same\n";
1296   }
1297   return 0;
1298 }
1299
1300 //=======================================================================
1301 //function : issubshape
1302 //purpose  : 
1303 //=======================================================================
1304 static Standard_Integer issubshape(Draw_Interpretor& di,
1305                                    Standard_Integer n,
1306                                    const char** a)
1307 {  
1308   if (n != 3) {
1309     di << "Check if the shape is sub-shape of other shape and get its index in the shape.\n";
1310     di << "Usage: issubshape subshape shape\n";
1311     return 1;
1312   }
1313   // get shapes
1314   TopoDS_Shape aSubShape = DBRep::Get(a[1]);
1315   TopoDS_Shape aShape    = DBRep::Get(a[2]);
1316   // check shapes
1317   if (aSubShape.IsNull() || aShape.IsNull()) {
1318     di << "null shapes\n";
1319     return 0;
1320   }
1321   // find index of the sub-shape in the shape
1322   TopTools_MapOfShape aMShapes;
1323   // try to find the SubShape in Shape
1324   TopExp_Explorer anExp(aShape, aSubShape.ShapeType());
1325   for (; anExp.More(); anExp.Next()) {
1326     const TopoDS_Shape& aSS = anExp.Current();
1327     if (aMShapes.Add(aSS)) {
1328       if (aSS.IsSame(aSubShape)) {
1329         break;
1330       }
1331     }
1332   }
1333   //
1334   if (anExp.More()) {
1335     di << a[1] << " is sub-shape of " << a[2] << ". Index in the shape: " << aMShapes.Extent() << ".\n";
1336   }
1337   else {
1338     di << a[1] << " is NOT sub-shape of " << a[2] << ".\n";
1339   }
1340   //
1341   return 0;
1342 }
1343
1344 void  BRepTest::BasicCommands(Draw_Interpretor& theCommands)
1345 {
1346   static Standard_Boolean done = Standard_False;
1347   if (done) return;
1348   done = Standard_True;
1349
1350   DBRep::BasicCommands(theCommands);
1351
1352   const char* g = "TOPOLOGY Basic shape commands";
1353
1354   theCommands.Add("addpcurve",
1355                   "addpcurve edge 2dcurve face [tol (default 1.e-7)]",
1356                   __FILE__,
1357                   addpcurve,g);
1358
1359   theCommands.Add("reset",
1360                   "reset name1 name2 ..., remove location",
1361                   __FILE__,
1362                   transform,g);
1363
1364   theCommands.Add("tmove",
1365                   "tmove name1 name2 ... name, set location from name [-copy]",
1366                   __FILE__,
1367                   transform,g);
1368
1369   theCommands.Add("ttranslate",
1370                   "ttranslate name1 name2 ... dx dy dz [-copy]",
1371                   __FILE__,
1372                   transform,g);
1373
1374   theCommands.Add("trotate",
1375                   "trotate name1 name2 ... x y z dx dy dz angle [-copy]",
1376                   __FILE__,
1377                   transform,g);
1378
1379   theCommands.Add("tmirror",
1380                   "tmirror name x y z dx dy dz [-copy]",
1381                   __FILE__,
1382                   transform,g);
1383
1384   theCommands.Add("tscale",
1385                   "tscale name x y z scale [-copy]",
1386                   __FILE__,
1387                   transform,g);
1388
1389   theCommands.Add("tcopy",
1390                   "tcopy [-n(ogeom)] [-m(esh)] name1 result1 [name2 result2 ...]",
1391                   __FILE__,
1392                   tcopy,g);
1393
1394   theCommands.Add("bmove",
1395                   "bmove name1 name2 ... name, set location from name",
1396                   __FILE__,
1397                   transform,g);
1398
1399   theCommands.Add("btranslate",
1400                   "btranslate name1 name2 ... dx dy dz",
1401                   __FILE__,
1402                   transform,g);
1403
1404   theCommands.Add("brotate",
1405                   "brotate name1 name2 ... x y z dx dy dz angle",
1406                   __FILE__,
1407                   transform,g);
1408
1409   theCommands.Add("bmirror",
1410                   "bmirror name x y z dx dy dz",
1411                   __FILE__,
1412                   transform,g);
1413
1414   theCommands.Add("bscale",
1415                   "bscale name x y z scale",
1416                   __FILE__,
1417                   transform,g);
1418
1419   theCommands.Add("precision",
1420                   "precision [preci]",
1421                   __FILE__,
1422                   precision,g);
1423
1424   theCommands.Add("mkedgecurve",
1425                   "mkedgecurve name tolerance",
1426                   __FILE__,
1427                   mkedgecurve,g);
1428
1429   theCommands.Add("fsameparameter",
1430                   "fsameparameter shapename [tol (default 1.e-7)], \nforce sameparameter on all edges of the shape",
1431                   __FILE__,
1432                   sameparameter,g);
1433
1434   theCommands.Add("sameparameter",
1435                   "sameparameter [result] shape [tol]",
1436                   __FILE__,
1437                   sameparameter,g);
1438
1439   theCommands.Add("updatetolerance",
1440                   "updatetolerance [result] shape [param] \n  if [param] is absent - not verify of face tolerance, else - perform it",
1441                   __FILE__,
1442                   updatetol,g);
1443
1444   theCommands.Add("solidorientation",
1445                   "orientsolid myClosedSolid",
1446                   __FILE__,
1447                   orientsolid,g);
1448
1449   theCommands.Add("getcoords",
1450     "getcoords vertex1 vertex 2... ; shows coords of input vertices",
1451     __FILE__,
1452     getcoords,g);
1453   
1454   theCommands.Add ("bounding",
1455                    "bounding {shape | xmin ymin zmin xmax ymax zmax}"
1456          "\n\t\t:            [-obb] [-noTriangulation] [-optimal] [-extToler]"
1457          "\n\t\t:            [-dump] [-shape name] [-nodraw]"
1458          "\n\t\t:            [-save xmin ymin zmin xmax ymax zmax]"
1459          "\n\t\t:"
1460          "\n\t\t: Computes a bounding box. Two types of the source data are supported:"
1461          "\n\t\t: a shape or AABB corners (xmin, ymin, zmin, xmax, ymax, zmax)."
1462          "\n\t\t:"
1463          "\n\t\t: Calculation options (applicable only if input is a shape):"
1464          "\n\t\t:  -obb     Compute Oriented Bounding Box (OBB) instead of AABB."
1465          "\n\t\t:  -noTriangulation Force use of exact geometry for calculation"
1466          "\n\t\t:                   even if triangulation is present."
1467          "\n\t\t:  -optimal Force calculation of optimal (more tight) AABB."
1468          "\n\t\t:           In case of OBB, applies to initial AABB used in OBB calculation."
1469          "\n\t\t:  -extToler Include tolerance of the shape in the resulting box."
1470          "\n\t\t:"
1471          "\n\t\t: Output options:"
1472          "\n\t\t:  -dump    Prints the information about computed Bounding Box."
1473          "\n\t\t:           It is enabled by default (with plain old syntax for AABB)"
1474          "\n\t\t:           if neither -shape nor -save is specified."
1475          "\n\t\t:  -shape   Stores computed box as solid in DRAW variable with specified name."
1476          "\n\t\t:  -save    Stores min and max coordinates of AABB in specified variables."
1477          "\n\t\t:  -noDraw  Avoid drawing resulting Bounding Box in DRAW viewer.",
1478                   __FILE__, BoundBox, g);
1479
1480  //
1481   theCommands.Add("gbounding",
1482                   "gbounding surf/curve/curve2d [-o] ",
1483                   __FILE__,
1484                   gbounding,g);
1485
1486   theCommands.Add("isbbinterf", "isbbinterf shape1 shape2 [-o]\n"
1487                   "Checks whether the bounding-boxes created from "
1488                   "the given shapes are interfered. If \"-o\"-option "
1489                   "is switched on then the oriented boxes will be checked. "
1490                   "Otherwise, axes-aligned boxes will be checked.",
1491                   __FILE__, IsBoxesInterfered, g);
1492
1493   theCommands.Add("nurbsconvert",
1494                   "nurbsconvert result name [result name]",
1495                   __FILE__,
1496                   nurbsconvert,g);
1497
1498   theCommands.Add("deform",
1499                   "deform newname name CoeffX CoeffY CoeffZ",
1500                   __FILE__,
1501                   deform,g);
1502   
1503   theCommands.Add("findplane",
1504                   "findplane name planename ",
1505                   __FILE__,
1506                   findplane,g) ;
1507   
1508   theCommands.Add("maxtolerance",
1509                   "maxtolerance shape ",
1510                   __FILE__,
1511                   maxtolerance,g) ;
1512
1513   theCommands.Add("reperageshape",
1514                   "reperage shape -> list of shape (result of interstion shape , line)",
1515                   __FILE__,
1516                   reperageshape,g) ;
1517
1518   theCommands.Add("vecdc",
1519                   "vecdc + Pointe double click ",
1520                   __FILE__,
1521                   vecdc,g) ;
1522
1523   theCommands.Add("nproject","nproject pj e1 e2 e3 ... surf -g -d [dmax] [Tol [continuity [maxdeg [maxseg]]]",
1524                   __FILE__,
1525                   nproject,g);
1526
1527   theCommands.Add("wexplo","wexplo wire [face] create WEDGE_i",
1528                   __FILE__,
1529                   wexplo,g);
1530
1531   theCommands.Add("scalexyz",
1532                   "scalexyz res shape factor_x factor_y factor_z",
1533                   __FILE__,
1534                   scalexyz, g);
1535
1536   theCommands.Add("compare",
1537                   "Compare shapes. Usage: compare shape1 shape2",
1538                   __FILE__,
1539                   compareshapes, g);
1540
1541   theCommands.Add("issubshape",
1542                   "issubshape subshape shape\n"
1543                   "\t\tCheck if the shape is sub-shape of other shape and get its index in the shape.",
1544                   __FILE__,
1545                   issubshape, g);
1546 }