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