0023654: Problem with displaying vertices in OCC view after closing all OCC views...
[occt.git] / src / ViewerTest / ViewerTest_ObjectCommands.cxx
1 // Created on: 1998-11-12
2 // Created by: Robert COUBLANC
3 // Copyright (c) 1998-1999 Matra Datavision
4 // Copyright (c) 1999-2012 OPEN CASCADE SAS
5 //
6 // The content of this file is subject to the Open CASCADE Technology Public
7 // License Version 6.5 (the "License"). You may not use the content of this file
8 // except in compliance with the License. Please obtain a copy of the License
9 // at http://www.opencascade.org and read it completely before using this file.
10 //
11 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
12 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
13 //
14 // The Original Code and all software distributed under the License is
15 // distributed on an "AS IS" basis, without warranty of any kind, and the
16 // Initial Developer hereby disclaims all such warranties, including without
17 // limitation, any warranties of merchantability, fitness for a particular
18 // purpose or non-infringement. Please see the License for the specific terms
19 // and conditions governing the rights and limitations under the License.
20
21
22
23 //===============================================
24 //    AIS Objects Creation : Datums (axis,trihedrons,lines,planes)
25 //===============================================
26
27 #ifdef HAVE_CONFIG_H
28 #include <config.h>
29 #endif
30
31 #include <ViewerTest.hxx>
32
33 #include <string.h>
34
35 #include <Quantity_NameOfColor.hxx>
36 #include <Draw_Interpretor.hxx>
37 #include <Draw.hxx>
38 #include <Draw_Appli.hxx>
39 #include <DBRep.hxx>
40
41 #include <OSD_Chronometer.hxx>
42 #include <TCollection_AsciiString.hxx>
43 #include <Visual3d_View.hxx>
44 #include <V3d_Viewer.hxx>
45 #include <V3d_View.hxx>
46 #include <V3d.hxx>
47
48 #include <AIS_Shape.hxx>
49 #include <AIS_DisplayMode.hxx>
50 #include <TColStd_MapOfInteger.hxx>
51 #include <AIS_MapOfInteractive.hxx>
52 #include <ViewerTest_DoubleMapOfInteractiveAndName.hxx>
53 #include <ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName.hxx>
54 #include <ViewerTest_EventManager.hxx>
55
56 #include <TopoDS_Solid.hxx>
57 #include <BRepTools.hxx>
58 #include <BRep_Builder.hxx>
59 #include <TopAbs_ShapeEnum.hxx>
60
61 #include <TopoDS.hxx>
62 #include <BRep_Tool.hxx>
63 #include <TopExp_Explorer.hxx>
64
65 #include <BRepAdaptor_Curve.hxx>
66 #include <BRepAdaptor_Surface.hxx>
67
68 #include <TopAbs.hxx>
69 #include <TopExp.hxx>
70 #include <TopoDS_Vertex.hxx>
71 #include <TopoDS_Shape.hxx>
72 #include <TopoDS_Face.hxx>
73
74 #include <Draw_Window.hxx>
75 #include <AIS_ListIteratorOfListOfInteractive.hxx>
76 #include <AIS_ListOfInteractive.hxx>
77 #include <AIS_DisplayMode.hxx>
78 #include <AIS_Shape.hxx>
79
80 #include <AIS_InteractiveContext.hxx>
81 #include <Geom_Plane.hxx>
82 #include <gp_Pln.hxx>
83 #include <AIS_AngleDimension.hxx>
84 #include <TCollection_ExtendedString.hxx>
85 #include <GC_MakePlane.hxx>
86 #include <gp_Circ.hxx>
87 #include <AIS_Axis.hxx>
88 #include <Geom_Axis2Placement.hxx>
89 #include <Geom_Axis1Placement.hxx>
90 #include <AIS_Trihedron.hxx>
91 #include <AIS_Axis.hxx>
92 #include <gp_Trsf.hxx>
93 #include <TopLoc_Location.hxx>
94
95 #include <HLRAlgo_Projector.hxx>
96 #include <HLRBRep_PolyAlgo.hxx>
97 #include <HLRBRep_PolyHLRToShape.hxx>
98 #include <Aspect_Window.hxx>
99
100 #include <Graphic3d_ArrayOfPoints.hxx>
101 #include <Graphic3d_ArrayOfSegments.hxx>
102 #include <Graphic3d_ArrayOfPolylines.hxx>
103 #include <Graphic3d_ArrayOfTriangles.hxx>
104 #include <Graphic3d_ArrayOfTriangleFans.hxx>
105 #include <Graphic3d_ArrayOfTriangleStrips.hxx>
106 #include <Graphic3d_ArrayOfQuadrangles.hxx>
107 #include <Graphic3d_ArrayOfQuadrangleStrips.hxx>
108 #include <Graphic3d_ArrayOfPolygons.hxx>
109 #include <Graphic3d_AspectMarker3d.hxx>
110 #include <Graphic3d_Group.hxx>
111 #include <Standard_Real.hxx>
112
113 #include <AIS_Circle.hxx>
114 #include <AIS_Drawer.hxx>
115 #include <BRepBuilderAPI_MakeEdge.hxx>
116 #include <BRepBuilderAPI_MakeFace.hxx>
117 #include <BRepBuilderAPI_MakeWire.hxx>
118 #include <Geom_Circle.hxx>
119 #include <GC_MakeCircle.hxx>
120 #include <Prs3d_Presentation.hxx>
121 #include <Select3D_SensitiveCircle.hxx>
122 #include <SelectMgr_EntityOwner.hxx>
123 #include <SelectMgr_Selection.hxx>
124 #include <StdFail_NotDone.hxx>
125 #include <StdPrs_ShadedShape.hxx>
126 #include <TopoDS_Wire.hxx>
127
128 #include <AIS_ConnectedShape.hxx>
129 #include <AIS_MultipleConnectedInteractive.hxx>
130 #include <AIS_MultipleConnectedShape.hxx>
131 #include <TopLoc_Location.hxx>
132 #include <TColStd_ListOfInteger.hxx>
133 #include <TColStd_ListIteratorOfListOfInteger.hxx>
134
135 #include <Select3D_SensitiveTriangle.hxx>
136 #include <Select3D_SensitiveCurve.hxx>
137 #include <Select3D_SensitivePoint.hxx>
138 #include <BRepAdaptor_Curve.hxx>
139 #include <StdPrs_Curve.hxx>
140
141 #include <BRepExtrema_ExtPC.hxx>
142 #include <BRepExtrema_ExtPF.hxx>
143
144 #include <Prs3d_LineAspect.hxx>
145 #include <Prs3d_PointAspect.hxx>
146
147 #include <Image_AlienPixMap.hxx>
148 #include <TColStd_HArray1OfAsciiString.hxx>
149
150 #ifdef HAVE_STRINGS_H
151 #include <strings.h>
152 #endif
153
154 #ifdef WNT
155 #define _CRT_SECURE_NO_DEPRECATE
156 #pragma warning (disable:4996)
157 #endif
158
159 extern ViewerTest_DoubleMapOfInteractiveAndName& GetMapOfAIS();
160 extern Standard_Boolean VDisplayAISObject (const TCollection_AsciiString& theName,
161                                            const Handle(AIS_InteractiveObject)& theAISObj,
162                                            Standard_Boolean theReplaceIfExists = Standard_True);
163 extern int ViewerMainLoop(Standard_Integer argc, const char** argv);
164 extern Handle(AIS_InteractiveContext)& TheAISContext();
165
166
167 //==============================================================================
168 //function : Vtrihedron 2d
169 //purpose  : Create a plane with a 2D  trihedron from a faceselection
170 //Draw arg : vtri2d  name
171 //==============================================================================
172 #include <AIS_PlaneTrihedron.hxx>
173
174
175
176 static int VTrihedron2D (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
177
178 {
179   // Verification des arguments
180   if ( argc!=2) {di<<argv[0]<<" error"<<"\n"; return 1;}
181
182   // Declarations
183   Standard_Integer myCurrentIndex;
184   // Fermeture des contextes
185   TheAISContext()->CloseAllContexts();
186   // Ouverture d'un contexte local et recuperation de son index.
187   TheAISContext()->OpenLocalContext();
188   myCurrentIndex=TheAISContext()->IndexOfCurrentLocal();
189   // On active les modes de selections faces.
190   TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(4) );
191   di<<" Select a face ."<<"\n";
192
193   // Boucle d'attente waitpick.
194   Standard_Integer argccc = 5;
195   const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
196   const char **argvvv = (const char **) bufff;
197   while (ViewerMainLoop( argccc, argvvv) ) { }
198   // fin de la boucle
199
200   TopoDS_Shape ShapeB;
201   for(TheAISContext()->InitSelected() ;TheAISContext()->MoreSelected() ;TheAISContext()->NextSelected() ) {
202     ShapeB = TheAISContext()->SelectedShape();
203   }
204
205   TopoDS_Face  FaceB=TopoDS::Face(ShapeB);
206
207   // Construction du Plane
208   // recuperation des edges des faces.
209   TopExp_Explorer FaceExpB(FaceB,TopAbs_EDGE);
210
211   TopoDS_Edge EdgeB=TopoDS::Edge(FaceExpB.Current() );
212   // declarations
213   gp_Pnt A,B,C;
214
215   // si il y a plusieurs edges
216   if (FaceExpB.More() ) {
217     FaceExpB.Next();
218     TopoDS_Edge EdgeC=TopoDS::Edge(FaceExpB.Current() );
219     BRepAdaptor_Curve theCurveB(EdgeB);
220     BRepAdaptor_Curve theCurveC(EdgeC);
221     A=theCurveC.Value(0.1);
222     B=theCurveC.Value(0.9);
223     C=theCurveB.Value(0.5);
224   }
225   else {
226     // FaceB a 1 unique edge courbe
227     BRepAdaptor_Curve theCurveB(EdgeB);
228     A=theCurveB.Value(0.1);
229     B=theCurveB.Value(0.9);
230     C=theCurveB.Value(0.5);
231   }
232   // Construction du Geom_Plane
233   GC_MakePlane MkPlane(A,B,C);
234   Handle(Geom_Plane) theGeomPlane=MkPlane.Value();
235
236   // Construction de l'AIS_PlaneTrihedron
237   Handle(AIS_PlaneTrihedron) theAISPlaneTri= new AIS_PlaneTrihedron(theGeomPlane );
238
239   // Fermeture du contexte local.
240   TheAISContext()->CloseLocalContext(myCurrentIndex);
241
242   // on le display & bind
243   TheAISContext()->Display(theAISPlaneTri );
244   GetMapOfAIS().Bind ( theAISPlaneTri ,argv[1]);
245
246   return 0;
247 }
248
249
250
251 //==============================================================================
252 //function : VTriherdron
253 //purpose  : Create a trihedron. If no arguments are set, the default
254 //           trihedron (Oxyz) is created.
255 //Draw arg : vtrihedron  name  [Xo] [Yo] [Zo] [Zu] [Zv] [Zw] [Xu] [Xv] [Xw]
256 //==============================================================================
257
258 static int VTrihedron (Draw_Interpretor& theDi,
259                        Standard_Integer  theArgsNb,
260                        const char**      theArgVec)
261 {
262   if (theArgsNb != 2 && theArgsNb != 5 && theArgsNb != 11)
263   {
264     theDi << theArgVec[0] << " Syntax error\n";
265     return 1;
266   }
267
268   gp_Pnt anOrigin (0.0, 0.0, 0.0);
269   gp_Dir aDirZ = gp::DZ();
270   gp_Dir aDirX = gp::DX();
271   Standard_Integer anArgIter = 2; // 1st is an IO name
272   if (anArgIter < theArgsNb)
273   {
274     anOrigin.SetX (Draw::Atof (theArgVec[anArgIter++]));
275     anOrigin.SetY (Draw::Atof (theArgVec[anArgIter++]));
276     anOrigin.SetZ (Draw::Atof (theArgVec[anArgIter++]));
277     if (anArgIter < theArgsNb)
278     {
279       Standard_Real aX = Draw::Atof (theArgVec[anArgIter++]);
280       Standard_Real aY = Draw::Atof (theArgVec[anArgIter++]);
281       Standard_Real aZ = Draw::Atof (theArgVec[anArgIter++]);
282       aDirZ.SetCoord (aX, aY, aZ);
283
284       aX = Draw::Atof (theArgVec[anArgIter++]);
285       aY = Draw::Atof (theArgVec[anArgIter++]);
286       aZ = Draw::Atof (theArgVec[anArgIter++]);
287       aDirX.SetCoord (aX, aY, aZ);
288     }
289   }
290
291   if (!aDirZ.IsNormal (aDirX, M_PI / 180.0))
292   {
293     theDi << theArgVec[0] << " - VectorX is not normal to VectorZ\n";
294     return 1;
295   }
296
297   Handle(Geom_Axis2Placement) aPlacement = new Geom_Axis2Placement (anOrigin, aDirZ, aDirX);
298   Handle(AIS_Trihedron) aShape = new AIS_Trihedron (aPlacement);
299   VDisplayAISObject (theArgVec[1], aShape);
300   return 0;
301 }
302
303 //==============================================================================
304 //function : VSize
305 //author   : ege
306 //purpose  : Change the size of a named or selected trihedron
307 //           if no name : it affects the trihedrons witch are selected otherwise nothing is donne
308 //           if no value, the value is set at 100 by default
309 //Draw arg : vsize [name] [size]
310 //==============================================================================
311
312 static int VSize (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
313
314 {
315   // Declaration de booleens
316   Standard_Boolean             ThereIsName;
317   Standard_Boolean             ThereIsCurrent;
318   Standard_Real                value;
319   Standard_Boolean             hascol;
320
321   Quantity_NameOfColor         col = Quantity_NOC_BLACK ;
322
323   // Verification des arguments
324   if ( argc>3 ) {di<<argv[0]<<" Syntaxe error"<<"\n"; return 1;}
325
326   // Verification du nombre d'arguments
327   if (argc==1)      {ThereIsName=Standard_False;value=100;}
328   else if (argc==2) {ThereIsName=Standard_False;value=Draw::Atof(argv[1]);}
329   else              {ThereIsName=Standard_True;value=Draw::Atof(argv[2]);}
330
331   // On ferme le contexte local pour travailler dans le contexte global
332   if(TheAISContext()->HasOpenedContext())
333     TheAISContext()->CloseLocalContext();
334
335   // On set le booleen ThereIsCurrent
336   if (TheAISContext() -> NbCurrents() > 0) {ThereIsCurrent=Standard_True;}
337   else {ThereIsCurrent=Standard_False;}
338
339
340
341   //===============================================================
342   // Il n'y a pas de nom  mais des objets selectionnes
343   //===============================================================
344   if (!ThereIsName && ThereIsCurrent)
345   {
346
347     ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName
348       it (GetMapOfAIS());
349
350     while ( it.More() ) {
351
352       Handle(AIS_InteractiveObject) aShape=
353         Handle(AIS_InteractiveObject)::DownCast(it.Key1());
354
355       if (!aShape.IsNull() &&  TheAISContext()->IsCurrent(aShape) )
356       {
357
358         // On verifie que l'AIS InteraciveObject selectionne est bien
359         // un AIS_Trihedron
360         if (aShape->Type()==AIS_KOI_Datum && aShape->Signature()==3) {
361
362           if (aShape->HasColor()) {
363             hascol=Standard_True;
364
365             // On recupere la couleur de aShape
366             col=aShape->Color();}
367
368           else hascol=Standard_False;
369
370           // On downcast aShape  de AIS_InteractiveObject a AIS_Trihedron
371           // pour lui appliquer la methode SetSize()
372           Handle(AIS_Trihedron) aTrihedron = *(Handle(AIS_Trihedron)*) &aShape;
373
374           // C'est bien un triedre,on chage sa valeur!
375           aTrihedron->SetSize(value);
376
377           // On donne la couleur au Trihedron
378           if(hascol)   aTrihedron->SetColor(col);
379           else         aTrihedron->UnsetColor();
380
381
382           // The trihedron hasn't be errased from the map
383           // so you just have to redisplay it
384           TheAISContext() ->Redisplay(aTrihedron,Standard_False);
385
386         }
387
388       }
389
390       it.Next();
391     }
392
393     TheAISContext() ->UpdateCurrentViewer();
394   }
395
396   //===============================================================
397   // Il n'y a pas d'arguments et aucuns objets selectionne Rien A Faire!
398   //===============================================================
399
400
401
402   //===============================================================
403   // Il y a un nom de triedre passe en argument
404   //===============================================================
405   if (ThereIsName) {
406     TCollection_AsciiString name=argv[1];
407
408     // on verifie que ce nom correspond bien a une shape
409     Standard_Boolean IsBound= GetMapOfAIS().IsBound2(name);
410
411     if (IsBound) {
412
413       // on recupere la shape dans la map des objets displayes
414       Handle(AIS_InteractiveObject) aShape =
415         Handle(AIS_InteractiveObject)::DownCast(GetMapOfAIS().Find2(name));
416
417       // On verifie que l'AIS InteraciveObject est bien
418       // un AIS_Trihedron
419       if (!aShape.IsNull() &&
420         aShape->Type()==AIS_KOI_Datum && aShape->Signature()==3)
421       {
422
423         if (aShape->HasColor()) {
424           hascol=Standard_True;
425
426           // On recupere la couleur de aShape
427           col=aShape->Color();}
428
429         else hascol=Standard_False;
430
431         // On downcast aShape de AIS_InteractiveObject a AIS_Trihedron
432         // pour lui appliquer la methode SetSize()
433         Handle(AIS_Trihedron) aTrihedron = *(Handle(AIS_Trihedron)*) &aShape;
434
435         // C'est bien un triedre,on chage sa valeur
436         aTrihedron->SetSize(value);
437
438         // On donne la couleur au Trihedron
439         if(hascol)   aTrihedron->SetColor(col);
440         else         aTrihedron->UnsetColor();
441
442         // The trihedron hasn't be errased from the map
443         // so you just have to redisplay it
444         TheAISContext() ->Redisplay(aTrihedron,Standard_False);
445
446         TheAISContext() ->UpdateCurrentViewer();
447       }
448     }
449   }
450   return 0;
451 }
452
453
454 //==============================================================================
455
456 //==============================================================================
457 //function : VPlaneTrihedron
458 //purpose  : Create a plane from a trihedron selection. If no arguments are set, the default
459 //Draw arg : vplanetri  name
460 //==============================================================================
461 #include <AIS_Plane.hxx>
462
463
464
465 static int VPlaneTrihedron (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
466
467 {
468   // Verification des arguments
469   if ( argc!=2) {di<<argv[0]<<" error"<<"\n"; return 1;}
470
471   // Declarations
472   Standard_Integer myCurrentIndex;
473   // Fermeture des contextes locaux
474   TheAISContext()->CloseAllContexts();
475
476   // On recupere tous les trihedrons de la GetMapOfAIS()
477   // et on active le mode de selection par face.
478   // =================================================
479
480   // Ouverture d'un contexte local et recuperation de son index.
481   TheAISContext()->OpenLocalContext(Standard_False);
482   myCurrentIndex=TheAISContext()->IndexOfCurrentLocal();
483
484   ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName
485     it (GetMapOfAIS());
486   while(it.More()){
487     Handle(AIS_InteractiveObject) ShapeA =
488       Handle(AIS_InteractiveObject)::DownCast(it.Key1());
489     // On verifie que c'est bien un trihedron
490     if (!ShapeA.IsNull() &&
491       ShapeA->Type()==AIS_KOI_Datum  && ShapeA->Signature()==3  ) {
492         // on le downcast
493         Handle(AIS_Trihedron) TrihedronA =((*(Handle(AIS_Trihedron)*)&ShapeA));
494         // on le charge dans le contexte et on active le mode Plane.
495         TheAISContext()->Load(TrihedronA,0,Standard_False);
496         TheAISContext()->Activate(TrihedronA,3);
497       }
498       it.Next();
499   }
500
501   di<<" Select a plane."<<"\n";
502   // Boucle d'attente waitpick.
503   Standard_Integer argccc = 5;
504   const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
505   const char **argvvv = (const char **) bufff;
506   while (ViewerMainLoop( argccc, argvvv) ) { }
507   // fin de la boucle
508
509   Handle(AIS_InteractiveObject) theIOB;
510   for(TheAISContext()->InitSelected() ;TheAISContext()->MoreSelected() ;TheAISContext()->NextSelected() ) {
511     theIOB = TheAISContext()->Interactive();
512   }
513   // on le downcast
514   Handle(AIS_Plane) PlaneB =((*(Handle(AIS_Plane)*)&theIOB));
515
516   // Fermeture du contexte local.
517   TheAISContext()->CloseLocalContext(myCurrentIndex);
518
519   // on le display & bind
520   TheAISContext()->Display(PlaneB );
521   GetMapOfAIS().Bind ( PlaneB ,argv[1]);
522
523   return 0;
524 }
525
526
527
528 //==============================================================================
529 // Fonction        First click      2de click
530 //
531 // vaxis           vertex           vertex
532 //                 edge             None
533 // vaxispara       edge             vertex
534 // vaxisortho      edge             Vertex
535 // vaxisinter      Face             Face
536 //==============================================================================
537
538 //==============================================================================
539 //function : VAxisBuilder
540 //purpose  :
541 //Draw arg : vaxis AxisName Xa Ya Za Xb Yb Zb
542 //==============================================================================
543 #include <TopoDS_Edge.hxx>
544 #include <TopoDS_Vertex.hxx>
545 #include <TopExp.hxx>
546 #include <Geom_Line.hxx>
547
548 static int VAxisBuilder(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
549 {
550   // Declarations
551   Standard_Boolean HasArg;
552   TCollection_AsciiString name;
553   Standard_Integer MyCurrentIndex;
554
555   // Verification
556   if (argc<2 || argc>8 ) {di<<" Syntaxe error"<<"\n";return 1;}
557   if (argc==8) HasArg=Standard_True;
558   else HasArg=Standard_False;
559
560   name=argv[1];
561   // Fermeture des contextes
562   TheAISContext()->CloseAllContexts();
563
564   // Cas ou il y a des arguments
565   // Purpose: Teste le constructeur AIS_Axis::AIS_Axis(x: Line from Geom)
566   if (HasArg) {
567     Standard_Real coord[6];
568     for(Standard_Integer i=0;i<=5;i++){
569       coord[i]=Draw::Atof(argv[2+i]);
570     }
571     gp_Pnt p1(coord[0],coord[1],coord[2]), p2(coord[3],coord[4],coord[5]) ;
572
573     gp_Vec myVect (p1,p2);
574     Handle(Geom_Line) myLine=new Geom_Line (p1 ,myVect );
575     Handle(AIS_Axis) TheAxis=new AIS_Axis (myLine );
576     GetMapOfAIS().Bind (TheAxis,name);
577     TheAISContext()->Display(TheAxis);
578   }
579
580   // Pas d'arguments
581   else {
582     // fonction vaxis
583     // Purpose: Teste le constructeur AIS_Axis::AIS_Axis (x:Axis1Placement from Geom)
584     if ( !strcasecmp(argv[0], "vaxis")) {
585       TheAISContext()->OpenLocalContext();
586       MyCurrentIndex=TheAISContext()->IndexOfCurrentLocal();
587
588       // Active le mode edge et le mode vertex
589       TheAISContext()->ActivateStandardMode(AIS_Shape::SelectionType(1) );
590       TheAISContext()->ActivateStandardMode(AIS_Shape::SelectionType(2) );
591       di<<" Select an edge or a vertex."<<"\n";
592
593       // Boucle d'attente waitpick.
594       Standard_Integer argcc = 5;
595       const char *buff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
596       const char **argvv = (const char **) buff;
597       while (ViewerMainLoop( argcc, argvv) ) { }
598       // fin de la boucle
599
600       // recuperation de la shape.
601       TopoDS_Shape ShapeA;
602       for(TheAISContext()->InitSelected() ;TheAISContext()->MoreSelected() ;TheAISContext()->NextSelected() ) {
603         ShapeA = TheAISContext()->SelectedShape();
604       }
605       // recuperation de l'AIS_InteractiveObject
606       //Handle(AIS_InteractiveObject) myAISio=TheAISContext()->Current();
607       // down cast en AIS_Point si sig et type
608       // AIS_Point -> Geom_Pnt ....
609
610       if (ShapeA.ShapeType()==TopAbs_VERTEX) {
611         // on desactive le mode edge
612         TheAISContext()->DeactivateStandardMode(AIS_Shape::SelectionType(2) );
613         di<<" Select a different vertex."<<"\n";
614
615         TopoDS_Shape ShapeB;
616         do {
617           // Boucle d'attente waitpick.
618           Standard_Integer argccc = 5;
619           const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
620           const char **argvvv = (const char **) bufff;
621           while (ViewerMainLoop( argccc, argvvv) ) { }
622           // fin de la boucle
623           for(TheAISContext()->InitSelected() ;TheAISContext()->MoreSelected() ;TheAISContext()->NextSelected() ) {
624             ShapeB = TheAISContext()->SelectedShape();
625           }
626
627
628         } while(ShapeB.IsSame(ShapeA) );
629
630         // Fermeture du context local
631         TheAISContext()->CloseLocalContext(MyCurrentIndex);
632
633         // Construction de l'axe
634         gp_Pnt   A=BRep_Tool::Pnt(TopoDS::Vertex(ShapeA)  );
635         gp_Pnt   B=BRep_Tool::Pnt(TopoDS::Vertex(ShapeB)  );
636         gp_Vec   V (A,B);
637         gp_Dir   D (V);
638         Handle(Geom_Axis1Placement) OrigineAndVect=new Geom_Axis1Placement (A,D);
639         Handle(AIS_Axis) TheAxis=new AIS_Axis (OrigineAndVect);
640         GetMapOfAIS().Bind (TheAxis,name);
641         TheAISContext()->Display(TheAxis);
642       }
643       else {
644         // Un unique edge (ShapeA) a ete picke
645         // Fermeture du context local
646         TheAISContext()->CloseLocalContext(MyCurrentIndex);
647         // Constuction de l'axe
648         TopoDS_Edge    ed =TopoDS::Edge(ShapeA);
649         TopoDS_Vertex  Va,Vb;
650         TopExp::Vertices(ed,Va,Vb );
651         gp_Pnt A=BRep_Tool::Pnt(Va);
652         gp_Pnt B=BRep_Tool::Pnt(Vb);
653         gp_Vec  V (A,B);
654         gp_Dir   D (V);
655         Handle(Geom_Axis1Placement) OrigineAndVect=new Geom_Axis1Placement (A,D);
656         Handle(AIS_Axis) TheAxis=new AIS_Axis (OrigineAndVect);
657         GetMapOfAIS().Bind (TheAxis,name);
658         TheAISContext()->Display(TheAxis);
659       }
660
661     }
662
663     // Fonction axispara
664     // Purpose: Teste le constructeur AIS_Axis::AIS_Axis(x: Axis2Placement from Geom, y: TypeOfAxis from AIS)
665     else if ( !strcasecmp(argv[0], "vaxispara")) {
666
667       TheAISContext()->OpenLocalContext();
668       MyCurrentIndex=TheAISContext()->IndexOfCurrentLocal();
669
670       // Active le mode edge
671       TheAISContext()->ActivateStandardMode(AIS_Shape::SelectionType(2) );
672       di<<" Select an edge."<<"\n";
673
674       // Boucle d'attente waitpick.
675       Standard_Integer argcc = 5;
676       const char *buff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
677       const char **argvv = (const char **) buff;
678       while (ViewerMainLoop( argcc, argvv) ) { }
679       // fin de la boucle
680
681       TopoDS_Shape ShapeA;
682       for(TheAISContext()->InitSelected() ;TheAISContext()->MoreSelected() ;TheAISContext()->NextSelected() ) {
683         ShapeA = TheAISContext()->SelectedShape();
684       }
685       // Active le mode vertex et deactive edges
686       TheAISContext()->DeactivateStandardMode(AIS_Shape::SelectionType(2) );
687       TheAISContext()->ActivateStandardMode(AIS_Shape::SelectionType(1) );
688       di<<" Select a vertex."<<"\n";
689
690       // Boucle d'attente waitpick.
691       Standard_Integer argccc = 5;
692       const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
693       const char **argvvv = (const char **) bufff;
694       while (ViewerMainLoop( argccc, argvvv) ) { }
695       // fin de la boucle
696
697       // On peut choisir un pnt sur l'edge
698       TopoDS_Shape ShapeB;
699       for(TheAISContext()->InitSelected() ;TheAISContext()->MoreSelected() ;TheAISContext()->NextSelected() ) {
700         ShapeB = TheAISContext()->SelectedShape();
701       }
702       // Fermeture du context local
703       TheAISContext()->CloseLocalContext(MyCurrentIndex);
704
705       // Construction de l'axe
706       TopoDS_Edge    ed=TopoDS::Edge(ShapeA) ;
707       gp_Pnt B=BRep_Tool::Pnt(TopoDS::Vertex(ShapeB) );
708       TopoDS_Vertex  Va,Vc;
709       TopExp::Vertices(ed,Va,Vc );
710       gp_Pnt A=BRep_Tool::Pnt(Va);
711       gp_Pnt C=BRep_Tool::Pnt(Vc);
712       gp_Vec  V (A,C);
713       gp_Dir   D (V);
714       Handle(Geom_Axis1Placement) OrigineAndVect=new Geom_Axis1Placement (B,D);
715       Handle(AIS_Axis) TheAxis=new AIS_Axis (OrigineAndVect);
716       GetMapOfAIS().Bind (TheAxis,name);
717       TheAISContext()->Display(TheAxis);
718
719     }
720
721     // Fonction axisortho
722     else  {
723       TheAISContext()->OpenLocalContext();
724       MyCurrentIndex=TheAISContext()->IndexOfCurrentLocal();
725
726       // Active le mode edge
727       TheAISContext()->ActivateStandardMode(AIS_Shape::SelectionType(2) );
728       di<<" Select an edge."<<"\n";
729
730       // Boucle d'attente waitpick.
731       Standard_Integer argcc = 5;
732       const char *buff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
733       const char **argvv = (const char **) buff;
734       while (ViewerMainLoop( argcc, argvv) ) { }
735       // fin de la boucle
736
737       TopoDS_Shape ShapeA;
738       for(TheAISContext()->InitSelected() ;TheAISContext()->MoreSelected() ;TheAISContext()->NextSelected() ) {
739         ShapeA = TheAISContext()->SelectedShape();
740       }
741       // Active le mode vertex et deactive edges
742       TheAISContext()->DeactivateStandardMode(AIS_Shape::SelectionType(2) );
743       TheAISContext()->ActivateStandardMode(AIS_Shape::SelectionType(1) );
744       di<<" Slect a vertex."<<"\n";
745
746       // Boucle d'attente waitpick.
747       Standard_Integer argccc = 5;
748       const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
749       const char **argvvv = (const char **) bufff;
750       while (ViewerMainLoop( argccc, argvvv) ) { }
751       // fin de la boucle
752
753       // On peut choisir un pnt sur l'edge
754       TopoDS_Shape ShapeB;
755       for(TheAISContext()->InitSelected() ;TheAISContext()->MoreSelected() ;TheAISContext()->NextSelected() ) {
756         ShapeB = TheAISContext()->SelectedShape();
757       }
758       // Fermeture du context local
759       TheAISContext()->CloseLocalContext(MyCurrentIndex);
760
761       // Construction de l'axe
762       TopoDS_Edge    ed=TopoDS::Edge(ShapeA) ;
763       gp_Pnt B=BRep_Tool::Pnt(TopoDS::Vertex(ShapeB) );
764       TopoDS_Vertex  Va,Vc;
765       TopExp::Vertices(ed,Va,Vc );
766       gp_Pnt A=BRep_Tool::Pnt(Va);
767       gp_Pnt C=BRep_Tool::Pnt(Vc);
768       gp_Pnt E(A.Y()+A.Z()-C.Y()-C.Z()  ,C.X()-A.X() ,C.X()-A.X() );
769       gp_Vec  V (A,E);
770       gp_Dir   D (V);
771       Handle(Geom_Axis1Placement) OrigineAndVect=new Geom_Axis1Placement (B,D);
772       Handle(AIS_Axis) TheAxis=new AIS_Axis (OrigineAndVect);
773       GetMapOfAIS().Bind (TheAxis,name);
774       TheAISContext()->Display(TheAxis);
775
776     }
777
778   }
779   return 0;
780 }
781
782
783 //==============================================================================
784 // Fonction        First click      Result
785 //
786 // vpoint          vertex           AIS_Point=Vertex
787 //                 edge             AIS_Point=Middle of the edge
788 //==============================================================================
789
790 //==============================================================================
791 //function : VPointBuilder
792 //purpose  : Build an AIS_Point from coordinates or with a selected vertex or edge
793 //Draw arg : vpoint PoinName [Xa] [Ya] [Za]
794 //==============================================================================
795 #include <TopoDS_Edge.hxx>
796 #include <TopoDS_Vertex.hxx>
797 #include <TopExp.hxx>
798 #include <AIS_Point.hxx>
799 #include <Geom_CartesianPoint.hxx>
800
801 static int VPointBuilder(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
802 {
803   // Declarations
804   Standard_Boolean HasArg;
805   TCollection_AsciiString name;
806   Standard_Integer myCurrentIndex;
807
808   // Verification
809   if (argc<2 || argc>5 ) {di<<" Syntaxe error"<<"\n";return 1;}
810   if (argc==5) HasArg=Standard_True;
811   else HasArg=Standard_False;
812
813   name=argv[1];
814   // Fermeture des contextes
815   TheAISContext()->CloseAllContexts();
816
817   // Il y a des arguments: teste l'unique constructeur AIS_Pnt::AIS_Pnt(Point from Geom)
818   if (HasArg) {
819     Standard_Real thecoord[3];
820     for(Standard_Integer i=0;i<=2;i++)
821       thecoord[i]=Draw::Atof(argv[2+i]);
822     Handle(Geom_CartesianPoint )  myGeomPoint= new Geom_CartesianPoint (thecoord[0],thecoord[1],thecoord[2]);
823     Handle(AIS_Point)  myAISPoint=new AIS_Point(myGeomPoint );
824     GetMapOfAIS().Bind (myAISPoint,name);
825     TheAISContext()->Display(myAISPoint);
826   }
827
828   // Il n'a pas d'arguments
829   else {
830     TheAISContext()->OpenLocalContext();
831     myCurrentIndex=TheAISContext()->IndexOfCurrentLocal();
832
833     // Active le mode Vertex et Edges
834     TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(1) );
835     TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(2) );
836     di<<" Select a vertex or an edge(build the middle)"<<"\n";
837
838     // Boucle d'attente waitpick.
839     Standard_Integer argcc = 5;
840     const char *buff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
841     const char **argvv = (const char **) buff;
842     while (ViewerMainLoop( argcc, argvv) ) { }
843     // fin de la boucle
844
845     TopoDS_Shape ShapeA;
846     for (TheAISContext()->InitSelected() ;TheAISContext()->MoreSelected() ;TheAISContext()->NextSelected() ) {
847       ShapeA= TheAISContext()->SelectedShape();
848     }
849
850     if (ShapeA.ShapeType()==TopAbs_VERTEX ) {
851       // Un vertex a ete selectionne
852       // Fermeture du context local
853       TheAISContext()->CloseLocalContext(myCurrentIndex);
854
855       // Construction du point
856       gp_Pnt A=BRep_Tool::Pnt(TopoDS::Vertex(ShapeA ) );
857       Handle(Geom_CartesianPoint) myGeomPoint= new Geom_CartesianPoint (A );
858       Handle(AIS_Point)  myAISPoint = new AIS_Point  (myGeomPoint );
859       GetMapOfAIS().Bind(myAISPoint,name);
860       TheAISContext()->Display(myAISPoint);
861     }
862     else {
863       // Un Edge a ete selectionne
864       // Fermeture du context local
865       TheAISContext()->CloseLocalContext(myCurrentIndex);
866
867       // Construction du point milieu de l'edge
868       TopoDS_Edge myEdge=TopoDS::Edge(ShapeA);
869       TopoDS_Vertex myVertexA,myVertexB;
870       TopExp::Vertices (myEdge ,myVertexA ,myVertexB );
871       gp_Pnt A=BRep_Tool::Pnt(myVertexA );
872       gp_Pnt B=BRep_Tool::Pnt(myVertexB );
873       // M est le milieu de [AB]
874       Handle(Geom_CartesianPoint) myGeomPointM= new Geom_CartesianPoint ( (A.X()+B.X())/2  , (A.Y()+B.Y())/2  , (A.Z()+B.Z())/2  );
875       Handle(AIS_Point)  myAISPointM = new AIS_Point  (myGeomPointM );
876       GetMapOfAIS().Bind(myAISPointM,name);
877       TheAISContext()->Display(myAISPointM);
878     }
879
880   }
881   return 0;
882
883 }
884
885 //==============================================================================
886 // Function        1st click   2de click  3de click
887 // vplane          Vertex      Vertex     Vertex
888 //                 Vertex      Edge
889 //                 Edge        Vertex
890 //                 Face
891 // vplanepara      Face        Vertex
892 //                 Vertex      Face
893 // vplaneortho     Face        Edge
894 //                 Edge        Face
895 //==============================================================================
896
897 //==============================================================================
898 //function : VPlaneBuilder
899 //purpose  : Build an AIS_Plane from selected entities or Named AIS components
900 //Draw arg : vplane PlaneName [AxisName]  [PointName]
901 //                            [PointName] [PointName] [PointName]
902 //                            [PlaneName] [PointName]
903 //==============================================================================
904
905 static Standard_Integer VPlaneBuilder (Draw_Interpretor& /*di*/,
906                                        Standard_Integer argc,
907                                        const char** argv)
908 {
909   // Declarations
910   Standard_Boolean hasArg;
911   TCollection_AsciiString aName;
912   Standard_Integer aCurrentIndex;
913
914   // Verification
915   if (argc<2 || argc>5 )
916   {
917     std::cout<<" Syntax error\n";
918     return 1;
919   }
920   if (argc==5 || argc==4)
921     hasArg=Standard_True;
922   else 
923     hasArg=Standard_False;
924
925   aName=argv[1];
926   // Close all contexts
927   TheAISContext()->CloseAllContexts();
928
929   // There are some arguments
930   if (hasArg)
931   {
932     if (!GetMapOfAIS().IsBound2(argv[2] ))
933     {
934       std::cout<<"vplane: error 1st name doesn't exist in the GetMapOfAIS()\n";
935       return 1;
936     }
937     // Get shape from map
938     Handle(AIS_InteractiveObject) aShapeA =
939       Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2(argv[2] ));
940
941     // The first argument is an AIS_Point
942     if (!aShapeA.IsNull() &&
943         aShapeA->Type()==AIS_KOI_Datum &&
944         aShapeA->Signature()==1)
945     {
946         // The second argument must also be an AIS_Point
947         if (argc<5 || !GetMapOfAIS().IsBound2(argv[3]))
948         {
949           std::cout<<"vplane: error 2nd name doesn't exist in the GetMapOfAIS()\n";
950           return 1;
951         }
952         // Get shape from map
953         Handle(AIS_InteractiveObject) aShapeB =
954           Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2(argv[3]));
955         // If B is not an AIS_Point
956         if (aShapeB.IsNull() ||
957           (!(aShapeB->Type()==AIS_KOI_Datum && aShapeB->Signature()==1)))
958         {
959           std::cout<<"vplane: error 2nd object is expected to be an AIS_Point.\n";
960           return 1;
961         }
962         // The third object is an AIS_Point
963         if (!GetMapOfAIS().IsBound2(argv[4]) ) 
964         {
965           std::cout<<"vplane: error 3d name doesn't exist in the GetMapOfAIS().\n";
966           return 1; 
967         }
968         // Get shape from map
969         Handle(AIS_InteractiveObject) aShapeC =
970           Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2(argv[4]));
971         // If C is not an AIS_Point
972         if (aShapeC.IsNull() ||
973           (!(aShapeC->Type()==AIS_KOI_Datum && aShapeC->Signature()==1)))
974         {
975           std::cout<<"vplane: error 3d object is expected to be an AIS_Point.\n";
976           return 1;
977         }
978
979         // Treatment of objects A, B, C
980         // Downcast an AIS_IO to AIS_Point
981         Handle(AIS_Point) anAISPointA = Handle(AIS_Point)::DownCast( aShapeA);
982         Handle(AIS_Point) anAISPointB = Handle(AIS_Point)::DownCast( aShapeB);
983         Handle(AIS_Point) anAISPointC = Handle(AIS_Point)::DownCast( aShapeC);
984
985         Handle(Geom_CartesianPoint ) aCartPointA = 
986           Handle(Geom_CartesianPoint)::DownCast( anAISPointA->Component());
987
988         Handle(Geom_CartesianPoint ) aCartPointB = 
989           Handle(Geom_CartesianPoint)::DownCast( anAISPointB->Component());
990
991         Handle(Geom_CartesianPoint ) aCartPointC = 
992           Handle(Geom_CartesianPoint)::DownCast( anAISPointC->Component());
993
994         // Verification that the three points are different
995         if(Abs(aCartPointB->X()-aCartPointA->X())<=Precision::Confusion() &&
996            Abs(aCartPointB->Y()-aCartPointA->Y())<=Precision::Confusion() &&
997            Abs(aCartPointB->Z()-aCartPointA->Z())<=Precision::Confusion())
998         {
999           // B=A
1000           std::cout<<"vplane error: same points"<<"\n";return 1;
1001         }
1002         if(Abs(aCartPointC->X()-aCartPointA->X())<=Precision::Confusion() &&
1003            Abs(aCartPointC->Y()-aCartPointA->Y())<=Precision::Confusion() &&
1004            Abs(aCartPointC->Z()-aCartPointA->Z())<=Precision::Confusion())
1005         {
1006           // C=A
1007           std::cout<<"vplane error: same points"<<"\n";return 1;
1008         }
1009         if(Abs(aCartPointC->X()-aCartPointB->X())<=Precision::Confusion() &&
1010            Abs(aCartPointC->Y()-aCartPointB->Y())<=Precision::Confusion() &&
1011            Abs(aCartPointC->Z()-aCartPointB->Z())<=Precision::Confusion())
1012         {
1013           // C=B
1014           std::cout<<"vplane error: same points"<<"\n";return 1;
1015         }
1016
1017         gp_Pnt A = aCartPointA->Pnt();
1018         gp_Pnt B = aCartPointB->Pnt();
1019         gp_Pnt C = aCartPointC->Pnt();
1020
1021         // Construction of AIS_Plane
1022         GC_MakePlane MkPlane (A,B,C);
1023         Handle(Geom_Plane) aGeomPlane = MkPlane.Value();
1024         Handle(AIS_Plane)  anAISPlane = new AIS_Plane(aGeomPlane );
1025         GetMapOfAIS().Bind (anAISPlane,aName );
1026         TheAISContext()->Display(anAISPlane);
1027       }
1028
1029       // The first argument is an AIS_Axis
1030       // Creation of a plane orthogonal to the axis through a point
1031     else if (aShapeA->Type()==AIS_KOI_Datum && aShapeA->Signature()==2 ) {
1032       // The second argument should be an AIS_Point
1033       if (argc!=4 || !GetMapOfAIS().IsBound2(argv[3] ) )
1034       {
1035         std::cout<<"vplane: error 2d name doesn't exist in the GetMapOfAIS()\n";
1036         return 1;
1037       }
1038       // Get shape from map
1039       Handle(AIS_InteractiveObject) aShapeB =
1040         Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2(argv[3]));
1041       // If B is not an AIS_Point
1042       if (aShapeB.IsNull() ||
1043         (!(aShapeB->Type()==AIS_KOI_Datum && aShapeB->Signature()==1)))
1044       {
1045         std::cout<<"vplane: error 2d object is expected to be an AIS_Point\n";
1046         return 1;
1047       }
1048
1049       // Treatment of objects A and B
1050       Handle(AIS_Axis) anAISAxisA = Handle(AIS_Axis)::DownCast(aShapeA);
1051       Handle(AIS_Point) anAISPointB = Handle(AIS_Point)::DownCast(aShapeB);
1052
1053       Handle(Geom_Line ) aGeomLineA = anAISAxisA ->Component();
1054       Handle(Geom_Point) aGeomPointB = anAISPointB->Component()  ;
1055
1056       gp_Ax1 anAxis = aGeomLineA->Position();
1057       Handle(Geom_CartesianPoint) aCartPointB = 
1058         Handle(Geom_CartesianPoint)::DownCast(aGeomPointB);
1059
1060       gp_Dir D =anAxis.Direction();
1061       gp_Pnt B = aCartPointB->Pnt();
1062
1063       // Construction of AIS_Plane
1064       Handle(Geom_Plane) aGeomPlane = new Geom_Plane(B,D);
1065       Handle(AIS_Plane) anAISPlane = new AIS_Plane(aGeomPlane,B );
1066       GetMapOfAIS().Bind (anAISPlane,aName );
1067       TheAISContext()->Display(anAISPlane);
1068
1069     }
1070     // The first argumnet is an AIS_Plane
1071     // Creation of a plane parallel to the plane passing through the point
1072     else if (aShapeA->Type()==AIS_KOI_Datum && aShapeA->Signature()==7)
1073     {
1074       // The second argument should be an AIS_Point
1075       if (argc!=4 || !GetMapOfAIS().IsBound2(argv[3]))
1076       {
1077         std::cout<<"vplane: error 2d name doesn't exist in the GetMapOfAIS()\n";
1078         return 1;
1079       }
1080       // Get shape from map
1081       Handle(AIS_InteractiveObject) aShapeB =
1082         Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2(argv[3]));
1083       // B should be an AIS_Point
1084       if (aShapeB.IsNull() ||
1085          (!(aShapeB->Type()==AIS_KOI_Datum && aShapeB->Signature()==1)))
1086       {
1087         std::cout<<"vplane: error 2d object is expected to be an AIS_Point\n";
1088         return 1;
1089       }
1090
1091       // Treatment of objects A and B
1092       Handle(AIS_Plane) anAISPlaneA = Handle(AIS_Plane)::DownCast(aShapeA);
1093       Handle(AIS_Point) anAISPointB = Handle(AIS_Point)::DownCast(aShapeB);
1094
1095       Handle(Geom_Plane) aNewGeomPlane= anAISPlaneA->Component();
1096       Handle(Geom_Point) aGeomPointB = anAISPointB->Component();
1097
1098       Handle(Geom_CartesianPoint) aCartPointB = 
1099         Handle(Geom_CartesianPoint)::DownCast(aGeomPointB);
1100       gp_Pnt B= aCartPointB->Pnt();
1101
1102       // Construction of an AIS_Plane
1103       Handle(AIS_Plane) anAISPlane = new AIS_Plane(aNewGeomPlane, B);
1104       GetMapOfAIS().Bind (anAISPlane, aName);
1105       TheAISContext()->Display(anAISPlane);
1106     }
1107     // Error
1108     else
1109     {
1110       std::cout<<"vplane: error 1st object is not an AIS\n";
1111       return 1;
1112     }
1113   }
1114   // There are no arguments
1115   else 
1116   {
1117     // Function vplane
1118     // Test the constructor AIS_Plane::AIS_Plane(Geom_Plane, Standard_Boolean )
1119     if (!strcasecmp(argv[0], "vplane"))
1120     {
1121       TheAISContext()->OpenLocalContext();
1122       aCurrentIndex=TheAISContext()->IndexOfCurrentLocal();
1123
1124       // Active modes Vertex, Edge and Face
1125       TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(1));
1126       TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(2));
1127       TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(4));
1128       std::cout<<"Select a vertex, a face or an edge\n";
1129
1130       // Wait for picking
1131       Standard_Integer argcc = 5;
1132       const char *buff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
1133       const char **argvv = (const char **) buff;
1134       while (ViewerMainLoop( argcc, argvv) ) { }
1135       // end of the loop
1136
1137       TopoDS_Shape aShapeA;
1138       for (TheAISContext()->InitSelected();
1139            TheAISContext()->MoreSelected();
1140            TheAISContext()->NextSelected())
1141       {
1142         aShapeA = TheAISContext()->SelectedShape();
1143       }
1144
1145       // aShapeA is a Vertex
1146       if (aShapeA.ShapeType()==TopAbs_VERTEX )
1147       {
1148         TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(4));
1149         std::cout<<" Select an edge or a different vertex\n";
1150
1151         // Wait for picking
1152         Standard_Integer argccc = 5;
1153         const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
1154         const char **argvvv = (const char **) bufff;
1155         while (ViewerMainLoop( argccc, argvvv) ) { }
1156         // end of the loop
1157
1158         TopoDS_Shape aShapeB;
1159         for (TheAISContext()->InitSelected();
1160           TheAISContext()->MoreSelected();
1161           TheAISContext()->NextSelected())
1162         {
1163           aShapeB = TheAISContext()->SelectedShape();
1164         }
1165         // aShapeB is a Vertex
1166         if (aShapeB.ShapeType()==TopAbs_VERTEX)
1167         {
1168           // A and B are the same
1169           if (aShapeB.IsSame(aShapeA))
1170           {
1171             std::cout<<" vplane: error, same points selected\n";
1172             return 1;
1173           }
1174           TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(2));
1175           std::cout<<" Select a different vertex\n";
1176
1177           // Wait for picking
1178           Standard_Integer argcccc = 5;
1179           const char *buffff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
1180           const char **argvvvv = (const char **) buffff;
1181           while (ViewerMainLoop( argcccc, argvvvv) ) { }
1182           // end of the loop
1183
1184           TopoDS_Shape aShapeC;
1185           for (TheAISContext()->InitSelected();
1186                TheAISContext()->MoreSelected();
1187                TheAISContext()->NextSelected())
1188           {
1189             aShapeC = TheAISContext()->SelectedShape();
1190           }
1191           // aShapeC is the same as A or B
1192           if (aShapeC.IsSame(aShapeA)||aShapeC.IsSame(aShapeB))
1193           {
1194             std::cout<<" vplane: error, same points selected\n";
1195             return 1;
1196           }
1197
1198           // Close the local context
1199           TheAISContext()->CloseLocalContext(aCurrentIndex);
1200
1201           // Construction of plane
1202           gp_Pnt A = BRep_Tool::Pnt(TopoDS::Vertex(aShapeA));
1203           gp_Pnt B = BRep_Tool::Pnt(TopoDS::Vertex(aShapeB));
1204           gp_Pnt C = BRep_Tool::Pnt(TopoDS::Vertex(aShapeC));
1205           GC_MakePlane MkPlane(A, B, C);
1206           Handle(Geom_Plane) aGeomPlane = MkPlane.Value();
1207           Handle(AIS_Plane) anAISPlane = new AIS_Plane (aGeomPlane);
1208           GetMapOfAIS().Bind (anAISPlane, aName);
1209           TheAISContext()->Display(anAISPlane);
1210         }
1211         // ShapeB is an edge
1212         else
1213         {
1214           // Verify that the vertex is not on the edge ShapeB
1215           TopoDS_Edge anEdgeB = TopoDS::Edge(aShapeB);
1216           TopoDS_Vertex aVertA = TopoDS::Vertex(aShapeA);
1217
1218           BRepExtrema_ExtPC OrthoProj(aVertA, anEdgeB);
1219           if (OrthoProj.SquareDistance(1)<Precision::Approximation())
1220           {
1221             // The vertex is on the edge
1222             std::cout<<" vplane: error point is on the edge\n";
1223             return 1;
1224           }
1225           else
1226           {
1227             // Close the local context
1228             TheAISContext()->CloseLocalContext(aCurrentIndex);
1229             // Construction of plane
1230             gp_Pnt A = BRep_Tool::Pnt(aVertA);
1231             TopoDS_Vertex aVBa, aVBb;
1232             TopExp::Vertices(anEdgeB ,aVBa ,aVBb);
1233             gp_Pnt aBa = BRep_Tool::Pnt(aVBa);
1234             gp_Pnt aBb = BRep_Tool::Pnt(aVBb);
1235             GC_MakePlane MkPlane (A, aBa, aBb);
1236             Handle(Geom_Plane) aGeomPlane = MkPlane.Value();
1237             Handle(AIS_Plane) anAISPlane = new AIS_Plane (aGeomPlane);
1238             GetMapOfAIS().Bind (anAISPlane, aName);
1239             TheAISContext()->Display(anAISPlane);
1240           }
1241         }
1242       }
1243       // aShapeA is an edge
1244       else if (aShapeA.ShapeType()==TopAbs_EDGE)
1245       {
1246         TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(4));
1247         TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(2));
1248         std::cout<<" Select a vertex that don't belong to the edge\n";
1249
1250         // Wait for picking
1251         Standard_Integer argccc = 5;
1252         const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
1253         const char **argvvv = (const char **) bufff;
1254         while (ViewerMainLoop( argccc, argvvv) ) { }
1255         // end of the loop
1256
1257         TopoDS_Shape aShapeB;
1258         for (TheAISContext()->InitSelected();
1259              TheAISContext()->MoreSelected();
1260              TheAISContext()->NextSelected())
1261         {
1262           aShapeB = TheAISContext()->SelectedShape();
1263         }
1264         // aShapeB should be a Vertex
1265         // Check that the vertex aShapeB is not on the edge
1266         TopoDS_Edge anEdgeA = TopoDS::Edge(aShapeA);
1267         TopoDS_Vertex aVertB = TopoDS::Vertex(aShapeB);
1268
1269         BRepExtrema_ExtPC OrthoProj (aVertB, anEdgeA);
1270         if (OrthoProj.SquareDistance(1)<Precision::Approximation())
1271         {
1272           // The vertex is on the edge
1273           std::cout<<" vplane: error point is on the edge\n";
1274           return 1;
1275         }
1276         else
1277         {
1278           // Close the local context
1279           TheAISContext()->CloseLocalContext(aCurrentIndex);
1280           // Construction of plane
1281           gp_Pnt B = BRep_Tool::Pnt(aVertB);
1282           TopoDS_Vertex aVAa, aVAb;
1283           TopExp::Vertices(anEdgeA, aVAa, aVAb);
1284           gp_Pnt Aa = BRep_Tool::Pnt(aVAa);
1285           gp_Pnt Ab = BRep_Tool::Pnt(aVAb);
1286           GC_MakePlane MkPlane (B,Aa,Ab);
1287           Handle(Geom_Plane) aGeomPlane = MkPlane.Value();
1288           Handle(AIS_Plane) anAISPlane = new AIS_Plane (aGeomPlane);
1289           GetMapOfAIS().Bind (anAISPlane ,aName);
1290           TheAISContext()->Display(anAISPlane);
1291         }
1292       }
1293       // aShapeA is a Face
1294       else
1295       {
1296         // Close the local context: nothing to select
1297         TheAISContext()->CloseLocalContext(aCurrentIndex);
1298         // Construction of plane
1299         TopoDS_Face aFace = TopoDS::Face(aShapeA);
1300         BRepAdaptor_Surface aSurface (aFace, Standard_False);
1301         if (aSurface.GetType()==GeomAbs_Plane)
1302         {
1303           gp_Pln aPlane = aSurface.Plane();
1304           Handle(Geom_Plane) aGeomPlane = new Geom_Plane(aPlane);
1305           Handle(AIS_Plane) anAISPlane = new AIS_Plane(aGeomPlane);
1306           GetMapOfAIS().Bind (anAISPlane, aName);
1307           TheAISContext()->Display(anAISPlane);
1308         }
1309         else
1310         {
1311           std::cout<<" vplane: error\n";
1312           return 1;
1313         }
1314       }
1315     }
1316
1317     // Function vPlanePara
1318     // ===================
1319     // test the constructor AIS_Plane::AIS_Plane(Geom_Plane,gp_Pnt)
1320     else if (!strcasecmp(argv[0], "vplanepara"))
1321     {
1322       TheAISContext()->OpenLocalContext();
1323       aCurrentIndex = TheAISContext()->IndexOfCurrentLocal();
1324
1325       // Activate modes Vertex and Face
1326       TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(1));
1327       TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(4));
1328       std::cout<<" Select a vertex or a face\n";
1329
1330       // Wait for picking
1331       Standard_Integer argcc = 5;
1332       const char *buff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
1333       const char **argvv = (const char **) buff;
1334       while (ViewerMainLoop( argcc, argvv) ) { }
1335       // end of the loop
1336
1337       TopoDS_Shape aShapeA;
1338       for (TheAISContext()->InitSelected();
1339            TheAISContext()->MoreSelected();
1340            TheAISContext()->NextSelected())
1341       {
1342         aShapeA = TheAISContext()->SelectedShape();
1343       }
1344
1345       if (aShapeA.ShapeType()==TopAbs_VERTEX )
1346       {
1347         // aShapeA is a vertex
1348         // Deactivate the mode Vertex
1349         TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(1));
1350         std::cout<<" Select a face\n";
1351
1352         // Wait for picking
1353         Standard_Integer argccc = 5;
1354         const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
1355         const char **argvvv = (const char **) bufff;
1356         while (ViewerMainLoop( argccc, argvvv) ) { }
1357         // end of the loop
1358
1359         TopoDS_Shape aShapeB;
1360         for (TheAISContext()->InitSelected();
1361              TheAISContext()->MoreSelected();
1362              TheAISContext()->NextSelected())
1363         {
1364           // A vertex ShapeA can be on Face ShapeB
1365           aShapeB = TheAISContext()->SelectedShape();
1366         }
1367
1368         // Close the local context
1369         TheAISContext()->CloseLocalContext(aCurrentIndex);
1370
1371         // Construction of plane
1372         gp_Pnt A = BRep_Tool::Pnt(TopoDS::Vertex(aShapeA));
1373
1374         TopoDS_Face aFace = TopoDS::Face(aShapeB);
1375         BRepAdaptor_Surface aSurface (aFace, Standard_False);
1376         if (aSurface.GetType()==GeomAbs_Plane )
1377         {
1378           gp_Pln aPlane = aSurface.Plane();
1379           // Construct a plane parallel to aGeomPlane through A
1380           aPlane.SetLocation(A);
1381           Handle(Geom_Plane) aGeomPlane = new Geom_Plane (aPlane);
1382           Handle(AIS_Plane) aAISPlane = new AIS_Plane (aGeomPlane, A);
1383           GetMapOfAIS().Bind (aAISPlane ,aName);
1384           TheAISContext()->Display(aAISPlane);
1385         }
1386         else
1387         {
1388           std::cout<<" vplanepara: error\n";
1389           return 1;
1390         }
1391       }
1392       else
1393       {
1394         // ShapeA is a Face
1395         // Deactive the mode Face
1396         TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(4));
1397         std::cout<<" Select a vertex\n";
1398
1399         // Wait for picking
1400         Standard_Integer argccc = 5;
1401         const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
1402         const char **argvvv = (const char **) bufff;
1403         while (ViewerMainLoop( argccc, argvvv) ) { }
1404         // end of the loop
1405
1406         TopoDS_Shape aShapeB;
1407         for (TheAISContext()->InitSelected();
1408              TheAISContext()->MoreSelected();
1409              TheAISContext()->NextSelected())
1410         {
1411           // A vertex ShapeB can be on Face ShapeA
1412           aShapeB = TheAISContext()->SelectedShape();
1413         }
1414         // Close the local context
1415         TheAISContext()->CloseLocalContext(aCurrentIndex);
1416
1417         // Construction of plane
1418         gp_Pnt B = BRep_Tool::Pnt(TopoDS::Vertex(aShapeB));
1419
1420         TopoDS_Face aFace=TopoDS::Face(aShapeA);
1421         BRepAdaptor_Surface aSurface (aFace, Standard_False);
1422         if (aSurface.GetType()==GeomAbs_Plane )
1423         {
1424           gp_Pln aPlane = aSurface.Plane();
1425           aPlane.SetLocation(B);
1426           Handle(Geom_Plane) aGeomPlane = new Geom_Plane (aPlane);
1427           // Construct a plane parallel to aGeomPlane through B
1428           Handle(AIS_Plane) anAISPlane = new AIS_Plane (aGeomPlane, B);
1429           GetMapOfAIS().Bind (anAISPlane, aName);
1430           TheAISContext()->Display(anAISPlane);
1431         }
1432         else
1433         {
1434           std::cout<<" vplanepara: error"<<"\n";return 1;
1435         }
1436       }
1437     }
1438
1439     // Function vplaneortho
1440     // ====================
1441     // test the constructor AIS_Plane::AIS_Plane(Geom_Plane,gp_Pnt,gp_Pnt,gp_Pnt)
1442     else
1443     {
1444       TheAISContext()->OpenLocalContext();
1445       aCurrentIndex = TheAISContext()->IndexOfCurrentLocal();
1446
1447       // Activate the modes Edge and Face
1448       TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(2));
1449       TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(4));
1450       std::cout<<" Select a face and an edge coplanar\n";
1451
1452       // Wait for picking
1453       Standard_Integer argcc = 5;
1454       const char *buff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
1455       const char **argvv = (const char **) buff;
1456       while (ViewerMainLoop( argcc, argvv) ) { }
1457       // end of the loop
1458
1459       TopoDS_Shape aShapeA;
1460       for (TheAISContext()->InitSelected();
1461            TheAISContext()->MoreSelected();
1462            TheAISContext()->NextSelected())
1463       {
1464         aShapeA = TheAISContext()->SelectedShape();
1465       }
1466
1467       if (aShapeA.ShapeType()==TopAbs_EDGE )
1468       {
1469         // ShapeA is an edge, deactivate the mode Edge...
1470         TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(2));
1471         std::cout<<" Select a face\n";
1472
1473         // Wait for picking
1474         Standard_Integer argccc = 5;
1475         const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
1476         const char **argvvv = (const char **) bufff;
1477         while (ViewerMainLoop( argccc, argvvv) ) { }
1478         // end of the loop
1479
1480         TopoDS_Shape aShapeB;
1481         for (TheAISContext()->InitSelected();
1482              TheAISContext()->MoreSelected();
1483              TheAISContext()->NextSelected())
1484         {
1485           // Edge ShapeA can be on Face ShapeB
1486           aShapeB = TheAISContext()->SelectedShape();
1487         }
1488
1489         // Close the local context
1490         TheAISContext()->CloseLocalContext(aCurrentIndex);
1491
1492         // Construction of plane
1493         TopoDS_Edge anEdgeA = TopoDS::Edge(aShapeA);
1494         TopoDS_Vertex aVAa, aVAb;
1495         TopExp::Vertices(anEdgeA, aVAa, aVAb);
1496         gp_Pnt Aa = BRep_Tool::Pnt(aVAa);
1497         gp_Pnt Ab = BRep_Tool::Pnt(aVAb);
1498         gp_Vec ab (Aa,Ab);
1499
1500         gp_Dir Dab (ab);
1501         // Creation of rotation axis
1502         gp_Ax1 aRotAxis (Aa,Dab);
1503
1504         TopoDS_Face aFace = TopoDS::Face(aShapeB);
1505         // The edge must be parallel to the face
1506         BRepExtrema_ExtPF aHeightA (aVAa, aFace);
1507         BRepExtrema_ExtPF aHeightB (aVAb, aFace);
1508         // Compare to heights
1509         if (fabs(sqrt(aHeightA.SquareDistance(1)) - sqrt(aHeightB.SquareDistance(1)))
1510             >Precision::Confusion())
1511         {
1512           // the edge is not parallel to the face
1513           std::cout<<" vplaneortho error: the edge is not parallel to the face\n";
1514           return 1;
1515         }
1516         // the edge is OK
1517         BRepAdaptor_Surface aSurface (aFace, Standard_False);
1518         if (aSurface.GetType()==GeomAbs_Plane)
1519         {
1520           gp_Pln aPlane = aSurface.Plane();
1521           // It rotates a half turn round the axis of rotation
1522           aPlane.Rotate(aRotAxis , M_PI/2);
1523
1524           Handle(Geom_Plane) aGeomPlane = new Geom_Plane (aPlane);
1525           // constructed aGeomPlane parallel to a plane containing the edge (center mid-edge)
1526           gp_Pnt aMiddle ((Aa.X()+Ab.X() )/2 ,(Aa.Y()+Ab.Y() )/2 ,(Aa.Z()+Ab.Z() )/2 );
1527           Handle(AIS_Plane) anAISPlane = new AIS_Plane (aGeomPlane, aMiddle);
1528           GetMapOfAIS().Bind (anAISPlane, aName);
1529           TheAISContext()->Display(anAISPlane);
1530         }
1531         else
1532         {
1533           std::cout<<" vplaneortho: error\n";
1534           return 1;
1535         }
1536       }
1537       else
1538       {
1539         // ShapeA is a Face, deactive the mode Face.
1540         TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(4));
1541         std::cout<<" Select an edge\n";
1542
1543         // Wait for picking
1544         Standard_Integer argccc = 5;
1545         const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
1546         const char **argvvv = (const char **) bufff;
1547         while (ViewerMainLoop( argccc, argvvv) ) { }
1548         // end of the loop
1549
1550         TopoDS_Shape aShapeB;
1551         for (TheAISContext()->InitSelected();
1552              TheAISContext()->MoreSelected();
1553              TheAISContext()->NextSelected())
1554         {
1555           // Edge ShapeB can be on Face ShapeA
1556           aShapeB = TheAISContext()->SelectedShape();
1557         }
1558         // Close the local context
1559         TheAISContext()->CloseLocalContext(aCurrentIndex);
1560
1561         // Construction of plane
1562         TopoDS_Edge anEdgeB = TopoDS::Edge(aShapeB);
1563         TopoDS_Vertex aVBa, aVBb;
1564         TopExp::Vertices(anEdgeB, aVBa, aVBb);
1565         gp_Pnt aBa = BRep_Tool::Pnt(aVBa);
1566         gp_Pnt aBb = BRep_Tool::Pnt(aVBb);
1567         gp_Vec ab (aBa,aBb);
1568         gp_Dir Dab (ab);
1569         // Creation of rotation axe
1570         gp_Ax1 aRotAxis (aBa,Dab);
1571
1572         TopoDS_Face aFace = TopoDS::Face(aShapeA);
1573         // The edge must be parallel to the face
1574         BRepExtrema_ExtPF aHeightA (aVBa, aFace);
1575         BRepExtrema_ExtPF aHeightB (aVBb, aFace);
1576         // Comparing the two heights
1577         if (fabs(sqrt(aHeightA.SquareDistance(1)) - sqrt(aHeightB.SquareDistance(1)))
1578             >Precision::Confusion())
1579         {
1580           // the edge is not parallel to the face
1581           std::cout<<" vplaneortho error: the edge is not parallel to the face\n";
1582           return 1;
1583         }
1584         // The edge is OK
1585         BRepAdaptor_Surface aSurface (aFace, Standard_False);
1586         if (aSurface.GetType()==GeomAbs_Plane)
1587         {
1588           gp_Pln aPlane = aSurface.Plane();
1589           // It rotates a half turn round the axis of rotation
1590           aPlane.Rotate(aRotAxis , M_PI/2);
1591           Handle(Geom_Plane) aGeomPlane = new Geom_Plane (aPlane);
1592           // constructed aGeomPlane parallel to a plane containing the edge theGeomPlane (center mid-edge)
1593           gp_Pnt aMiddle ((aBa.X()+aBb.X() )/2 , (aBa.Y()+aBb.Y() )/2 , (aBa.Z()+aBb.Z() )/2 );
1594           Handle(AIS_Plane) anAISPlane = new AIS_Plane (aGeomPlane, aMiddle);
1595           GetMapOfAIS().Bind (anAISPlane ,aName);
1596           TheAISContext()->Display(anAISPlane);
1597         }
1598         else
1599         {
1600           std::cout<<" vplaneortho: error\n";
1601           return 1;
1602         }
1603       }
1604     }
1605   }
1606   return 0;
1607 }
1608
1609
1610 //==============================================================================
1611 // Fonction  vline
1612 // ---------------  Uniquement par parametre. Pas de selection dans le viewer.
1613 //==============================================================================
1614
1615 //==============================================================================
1616 //function : VLineBuilder
1617 //purpose  : Build an AIS_Line
1618 //Draw arg : vline LineName  [AIS_PointName] [AIS_PointName]
1619 //                           [Xa] [Ya] [Za]   [Xb] [Yb] [Zb]
1620 //==============================================================================
1621 #include <Geom_CartesianPoint.hxx>
1622 #include <AIS_Line.hxx>
1623
1624
1625 static int VLineBuilder(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
1626 {
1627   Standard_Integer myCurrentIndex;
1628   // Verifications
1629   if (argc!=4 && argc!=8 && argc!=2 )  {di<<"vline error: number of arguments not correct "<<"\n";return 1; }
1630   // Fermeture des contextes
1631   TheAISContext()->CloseAllContexts();
1632
1633   // On recupere les parametres
1634   Handle(AIS_InteractiveObject) theShapeA;
1635   Handle(AIS_InteractiveObject) theShapeB;
1636
1637   // Parametres: AIS_Point AIS_Point
1638   // ===============================
1639   if (argc==4) {
1640     theShapeA=
1641       Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2(argv[2]));
1642     // On verifie que c'est bien une AIS_Point
1643     if (!theShapeA.IsNull() &&
1644       theShapeA->Type()==AIS_KOI_Datum && theShapeA->Signature()==1) {
1645         // on recupere le deuxieme AIS_Point
1646         theShapeB=
1647           Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2(argv[3]));
1648         if (theShapeA.IsNull() ||
1649           (!(theShapeB->Type()==AIS_KOI_Datum && theShapeB->Signature()==1)))
1650         {
1651           di <<"vline error: wrong type of 2de argument."<<"\n";
1652           return 1;
1653         }
1654       }
1655     else {di <<"vline error: wrong type of 1st argument."<<"\n";return 1; }
1656     // Les deux parametres sont du bon type. On verifie que les points ne sont pas confondus
1657     Handle(AIS_Point) theAISPointA= *(Handle(AIS_Point)*)& theShapeA;
1658     Handle(AIS_Point) theAISPointB= *(Handle(AIS_Point)*)& theShapeB;
1659
1660     Handle(Geom_Point ) myGeomPointBA=  theAISPointA->Component();
1661     Handle(Geom_CartesianPoint ) myCartPointA= *((Handle(Geom_CartesianPoint)*)&  myGeomPointBA);
1662     //    Handle(Geom_CartesianPoint ) myCartPointA= *(Handle(Geom_CartesianPoint)*)& (theAISPointA->Component() ) ;
1663
1664     Handle(Geom_Point ) myGeomPointB=  theAISPointB->Component();
1665     Handle(Geom_CartesianPoint ) myCartPointB= *((Handle(Geom_CartesianPoint)*)&  myGeomPointB);
1666     //    Handle(Geom_CartesianPoint ) myCartPointB= *(Handle(Geom_CartesianPoint)*)& (theAISPointB->Component() ) ;
1667
1668     if (myCartPointB->X()==myCartPointA->X() && myCartPointB->Y()==myCartPointA->Y() && myCartPointB->Z()==myCartPointA->Z() ) {
1669       // B=A
1670       di<<"vline error: same points"<<"\n";return 1;
1671     }
1672     // Les deux points sont OK...Construction de l'AIS_Line (en faite, le segment AB)
1673     Handle(AIS_Line) theAISLine= new AIS_Line(myCartPointA,myCartPointB );
1674     GetMapOfAIS().Bind(theAISLine,argv[1] );
1675     TheAISContext()->Display(theAISLine );
1676
1677   }
1678
1679   // Parametres 6 Reals
1680   // ==================
1681
1682   else if (argc==8) {
1683     // On verifie que les deux points ne sont pas confondus
1684
1685     Standard_Real coord[6];
1686     for(Standard_Integer i=0;i<=2;i++){
1687       coord[i]=Draw::Atof(argv[2+i]);
1688       coord[i+3]=Draw::Atof(argv[5+i]);
1689     }
1690
1691     Handle(Geom_CartesianPoint ) myCartPointA=new Geom_CartesianPoint (coord[0],coord[1],coord[2] );
1692     Handle(Geom_CartesianPoint ) myCartPointB=new Geom_CartesianPoint (coord[3],coord[4],coord[5] );
1693
1694     Handle(AIS_Line) theAISLine= new AIS_Line(myCartPointA,myCartPointB );
1695     GetMapOfAIS().Bind(theAISLine,argv[1] );
1696     TheAISContext()->Display(theAISLine );
1697
1698   }
1699
1700   // Pas de parametres: Selection dans le viewer.
1701   // ============================================
1702
1703   else {
1704     TheAISContext()->OpenLocalContext();
1705     myCurrentIndex=TheAISContext()->IndexOfCurrentLocal();
1706
1707     // Active le mode Vertex.
1708     TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(1) );
1709     di<<" Select a vertex "<<"\n";
1710
1711     // Boucle d'attente waitpick.
1712     Standard_Integer argcc = 5;
1713     const char *buff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
1714     const char **argvv = (const char **) buff;
1715     while (ViewerMainLoop( argcc, argvv) ) { }
1716     // fin de la boucle
1717
1718     TopoDS_Shape ShapeA;
1719     for(TheAISContext()->InitSelected() ;TheAISContext()->MoreSelected() ;TheAISContext()->NextSelected() ) {
1720       ShapeA = TheAISContext()->SelectedShape();
1721     }
1722
1723     // ShapeA est un Vertex
1724     if (ShapeA.ShapeType()==TopAbs_VERTEX ) {
1725
1726       di<<" Select a different vertex."<<"\n";
1727
1728       TopoDS_Shape ShapeB;
1729       do {
1730
1731         // Boucle d'attente waitpick.
1732         Standard_Integer argccc = 5;
1733         const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
1734         const char **argvvv = (const char **) bufff;
1735         while (ViewerMainLoop( argccc, argvvv) ) { }
1736         // fin de la boucle
1737
1738         for(TheAISContext()->InitSelected() ;TheAISContext()->MoreSelected() ;TheAISContext()->NextSelected() ) {
1739           ShapeB = TheAISContext()->SelectedShape();
1740         }
1741
1742
1743       } while(ShapeB.IsSame(ShapeA) );
1744
1745       // Fermeture du context local
1746       TheAISContext()->CloseLocalContext(myCurrentIndex);
1747
1748       // Construction de la line
1749       gp_Pnt   A=BRep_Tool::Pnt(TopoDS::Vertex(ShapeA)  );
1750       gp_Pnt   B=BRep_Tool::Pnt(TopoDS::Vertex(ShapeB)  );
1751
1752       Handle(Geom_CartesianPoint ) myCartPointA=new Geom_CartesianPoint(A);
1753       Handle(Geom_CartesianPoint ) myCartPointB=new Geom_CartesianPoint(B);
1754
1755       Handle(AIS_Line) theAISLine= new AIS_Line(myCartPointA,myCartPointB );
1756       GetMapOfAIS().Bind(theAISLine,argv[1] );
1757       TheAISContext()->Display(theAISLine );
1758
1759     }
1760     else  {
1761       di<<"vline error."<<"\n";
1762     }
1763
1764   }
1765
1766   return 0;
1767 }
1768
1769 //==============================================================================
1770 // class   : FilledCircle
1771 // purpose : creates filled circle based on AIS_InteractiveObject 
1772 //           and Geom_Circle.
1773 //           This class is used to check method Matches() of class 
1774 //           Select3D_SensitiveCircle with member myFillStatus = Standard_True, 
1775 //           because none of AIS classes provides creation of 
1776 //           Select3D_SensitiveCircle with member myFillStatus = Standard_True 
1777 //           (look method ComputeSelection() )
1778 //============================================================================== 
1779
1780 Handle(Geom_Circle) CreateCircle(gp_Pnt theCenter, Standard_Real theRadius) 
1781 {
1782   gp_Ax2 anAxes(theCenter, gp_Dir(gp_Vec(0., 0., 1.))); 
1783   gp_Circ aCirc(anAxes, theRadius);
1784   Handle(Geom_Circle) aCircle = new Geom_Circle(aCirc);
1785   return aCircle;
1786 }
1787
1788 DEFINE_STANDARD_HANDLE(FilledCircle, AIS_InteractiveObject)
1789
1790 class FilledCircle : public AIS_InteractiveObject 
1791 {
1792 public:
1793     // CASCADE RTTI
1794     DEFINE_STANDARD_RTTI(FilledCircle); 
1795
1796     FilledCircle(gp_Pnt theCenter, Standard_Real theRadius);
1797     FilledCircle(Handle(Geom_Circle) theCircle);
1798
1799 private:
1800     TopoDS_Face ComputeFace();
1801
1802     // Virtual methods implementation
1803     void Compute (  const Handle(PrsMgr_PresentationManager3d)& thePresentationManager,
1804                   const Handle(Prs3d_Presentation)& thePresentation,
1805                   const Standard_Integer theMode);
1806
1807     void ComputeSelection (  const Handle(SelectMgr_Selection)& theSelection, 
1808                            const Standard_Integer theMode);
1809
1810 protected:
1811     Handle(Geom_Circle) myCircle;
1812     Standard_Boolean myFilledStatus;
1813
1814 }; 
1815
1816 IMPLEMENT_STANDARD_HANDLE(FilledCircle, AIS_InteractiveObject)
1817 IMPLEMENT_STANDARD_RTTIEXT(FilledCircle, AIS_InteractiveObject)
1818
1819 FilledCircle::FilledCircle(gp_Pnt theCenter, Standard_Real theRadius) 
1820 {
1821   myCircle = CreateCircle(theCenter, theRadius);
1822   myFilledStatus = Standard_True;
1823 }
1824
1825 FilledCircle::FilledCircle(Handle(Geom_Circle) theCircle) 
1826 {
1827   myCircle = theCircle;
1828   myFilledStatus = Standard_True;
1829 }
1830
1831 TopoDS_Face FilledCircle::ComputeFace() 
1832 {
1833   // Create edge from myCircle 
1834   BRepBuilderAPI_MakeEdge anEdgeMaker(myCircle->Circ());
1835   TopoDS_Edge anEdge = anEdgeMaker.Edge(); 
1836
1837   // Create wire from anEdge 
1838   BRepBuilderAPI_MakeWire aWireMaker(anEdge);
1839   TopoDS_Wire aWire = aWireMaker.Wire();
1840
1841   // Create face from aWire
1842   BRepBuilderAPI_MakeFace aFaceMaker(aWire);
1843   TopoDS_Face aFace = aFaceMaker.Face();
1844
1845   return aFace;
1846 }
1847
1848 void FilledCircle::Compute(const Handle_PrsMgr_PresentationManager3d &/*thePresentationManager*/, 
1849                            const Handle_Prs3d_Presentation &thePresentation, 
1850                            const Standard_Integer theMode) 
1851 {
1852   thePresentation->Clear();
1853
1854   TopoDS_Face aFace = ComputeFace();
1855
1856   if (aFace.IsNull()) return;
1857   if (theMode != 0) return;
1858
1859   StdPrs_ShadedShape::Add(thePresentation, aFace, myDrawer);
1860 }
1861
1862 void FilledCircle::ComputeSelection(const Handle_SelectMgr_Selection &theSelection, 
1863                                     const Standard_Integer /*theMode*/)
1864 {
1865   Handle(SelectMgr_EntityOwner) anEntityOwner = new SelectMgr_EntityOwner(this);
1866   Handle(Select3D_SensitiveCircle) aSensitiveCircle = new Select3D_SensitiveCircle(anEntityOwner, 
1867       myCircle, myFilledStatus);
1868   theSelection->Add(aSensitiveCircle);
1869 }
1870
1871 //==============================================================================
1872 // Fonction  vcircle
1873 // -----------------  Uniquement par parametre. Pas de selection dans le viewer.
1874 //==============================================================================
1875
1876 //==============================================================================
1877 //function : VCircleBuilder
1878 //purpose  : Build an AIS_Circle
1879 //Draw arg : vcircle CircleName PlaneName PointName Radius IsFilled
1880 //                              PointName PointName PointName IsFilled
1881 //==============================================================================
1882
1883 void DisplayCircle (Handle (Geom_Circle) theGeomCircle,
1884                     TCollection_AsciiString theName, 
1885                     Standard_Boolean isFilled) 
1886 {
1887   Handle(AIS_InteractiveObject) aCircle;
1888   if (isFilled) 
1889   {
1890     aCircle = new FilledCircle(theGeomCircle);
1891   }
1892   else
1893   {
1894     aCircle = new AIS_Circle(theGeomCircle);
1895   }
1896
1897   // Check if there is an object with given name
1898   // and remove it from context
1899   if (GetMapOfAIS().IsBound2(theName)) 
1900   {
1901     Handle(Standard_Transient) anObj = GetMapOfAIS().Find2(theName);
1902     Handle(AIS_InteractiveObject) anInterObj = 
1903          Handle(AIS_InteractiveObject)::DownCast(anObj);
1904     TheAISContext()->Remove(anInterObj, Standard_False);
1905     GetMapOfAIS().UnBind2(theName);
1906    }
1907
1908    // Bind the circle to its name
1909    GetMapOfAIS().Bind(aCircle, theName);
1910
1911    // Display the circle
1912    TheAISContext()->Display(aCircle);
1913   
1914 }
1915
1916 static int VCircleBuilder(Draw_Interpretor& /*di*/, Standard_Integer argc, const char** argv)
1917 {
1918   Standard_Integer myCurrentIndex;
1919   // Verification of the arguments
1920   if (argc>6 || argc<2) 
1921   { 
1922     std::cout << "vcircle error: expect 4 arguments.\n"; 
1923     return 1; // TCL_ERROR 
1924   }
1925   TheAISContext()->CloseAllContexts();
1926
1927   // There are all arguments
1928   if (argc == 6) 
1929   {
1930     // Get arguments
1931     TCollection_AsciiString aName(argv[1]);
1932     Standard_Boolean isFilled = (Standard_Boolean)Draw::Atoi(argv[5]);
1933
1934     Handle(AIS_InteractiveObject) theShapeA;
1935     Handle(AIS_InteractiveObject) theShapeB;
1936
1937     theShapeA =
1938       Handle(AIS_InteractiveObject)::DownCast(GetMapOfAIS().Find2(argv[2]));
1939     theShapeB =
1940       Handle(AIS_InteractiveObject)::DownCast(GetMapOfAIS().Find2(argv[3]));
1941
1942
1943     // Arguments: AIS_Point AIS_Point AIS_Point
1944     // ========================================
1945     if (!theShapeA.IsNull() && !theShapeB.IsNull() &&
1946       theShapeA->Type()==AIS_KOI_Datum && theShapeA->Signature()==1)
1947     {
1948       if (theShapeB->Type()!=AIS_KOI_Datum || theShapeB->Signature()!=1 ) 
1949       {
1950         std::cout << "vcircle error: 2d argument is unexpected to be a point.\n";
1951         return 1; // TCL_ERROR 
1952       }
1953       // The third object must be a point
1954       Handle(AIS_InteractiveObject) theShapeC =
1955         Handle(AIS_InteractiveObject)::DownCast(GetMapOfAIS().Find2(argv[4]));
1956       if (theShapeC.IsNull() ||
1957         theShapeC->Type()!=AIS_KOI_Datum || theShapeC->Signature()!=1 ) 
1958       {
1959         std::cout << "vcircle error: 3d argument is unexpected to be a point.\n";
1960         return 1; // TCL_ERROR 
1961       }
1962         // tag
1963         // Verify that the three points are different
1964         Handle(AIS_Point) theAISPointA = Handle(AIS_Point)::DownCast(theShapeA);
1965         Handle(AIS_Point) theAISPointB = Handle(AIS_Point)::DownCast(theShapeB);
1966         Handle(AIS_Point) theAISPointC = Handle(AIS_Point)::DownCast(theShapeC);
1967         
1968         Handle(Geom_Point) myGeomPointA = theAISPointA->Component();
1969         Handle(Geom_CartesianPoint) myCartPointA = 
1970           Handle(Geom_CartesianPoint)::DownCast(myGeomPointA);
1971
1972         Handle(Geom_Point) myGeomPointB = theAISPointB->Component();
1973         Handle(Geom_CartesianPoint) myCartPointB =
1974           Handle(Geom_CartesianPoint)::DownCast(myGeomPointB);
1975
1976         Handle(Geom_Point) myGeomPointC = theAISPointC->Component();
1977         Handle(Geom_CartesianPoint) myCartPointC =
1978           Handle(Geom_CartesianPoint)::DownCast(myGeomPointC);
1979
1980         // Test A=B
1981         if (Abs(myCartPointA->X()-myCartPointB->X()) <= Precision::Confusion() && 
1982             Abs(myCartPointA->Y()-myCartPointB->Y()) <= Precision::Confusion() && 
1983             Abs(myCartPointA->Z()-myCartPointB->Z()) <= Precision::Confusion() ) 
1984         {
1985           std::cout << "vcircle error: Same points.\n"; 
1986           return 1; // TCL_ERROR 
1987         }
1988         // Test A=C
1989         if (Abs(myCartPointA->X()-myCartPointC->X()) <= Precision::Confusion() &&
1990             Abs(myCartPointA->Y()-myCartPointC->Y()) <= Precision::Confusion() && 
1991             Abs(myCartPointA->Z()-myCartPointC->Z()) <= Precision::Confusion() ) 
1992         {
1993           std::cout << "vcircle error: Same points.\n"; 
1994           return 1; // TCL_ERROR 
1995         }
1996         // Test B=C
1997         if (Abs(myCartPointB->X()-myCartPointC->X()) <= Precision::Confusion() && 
1998             Abs(myCartPointB->Y()-myCartPointC->Y()) <= Precision::Confusion() && 
1999             Abs(myCartPointB->Z()-myCartPointC->Z()) <= Precision::Confusion() ) 
2000         {
2001           std::cout << "vcircle error: Same points.\n"; 
2002           return 1;// TCL_ERROR 
2003         }
2004         // Construction of the circle
2005         GC_MakeCircle Cir = GC_MakeCircle (myCartPointA->Pnt(), 
2006           myCartPointB->Pnt(), myCartPointC->Pnt() );
2007         Handle (Geom_Circle) theGeomCircle;
2008         try 
2009         {
2010           theGeomCircle = Cir.Value();
2011         }
2012         catch (StdFail_NotDone)
2013         {
2014           std::cout << "vcircle error: can't create circle\n";
2015           return -1; // TCL_ERROR
2016         }
2017         
2018         DisplayCircle(theGeomCircle, aName, isFilled);
2019     }
2020
2021     // Arguments: AIS_Plane AIS_Point Real
2022     // ===================================
2023     else if (theShapeA->Type() == AIS_KOI_Datum && 
2024       theShapeA->Signature() == 7 ) 
2025     {
2026       if (theShapeB->Type() != AIS_KOI_Datum || 
2027         theShapeB->Signature() != 1 ) 
2028       {
2029         std::cout << "vcircle error: 2d element is a unexpected to be a point.\n"; 
2030         return 1; // TCL_ERROR 
2031       }
2032       // Ñheck that the radius is >= 0
2033       if (Draw::Atof(argv[4]) <= 0 ) 
2034       {
2035         std::cout << "vcircle error: the radius must be >=0.\n"; 
2036         return 1; // TCL_ERROR 
2037       }
2038
2039       // Recover the normal to the plane
2040       Handle(AIS_Plane) theAISPlane = Handle(AIS_Plane)::DownCast(theShapeA);
2041       Handle(AIS_Point) theAISPointB = Handle(AIS_Point)::DownCast(theShapeB); 
2042
2043       Handle(Geom_Plane) myGeomPlane = theAISPlane->Component();
2044       Handle(Geom_Point) myGeomPointB = theAISPointB->Component();
2045       Handle(Geom_CartesianPoint) myCartPointB = 
2046         Handle(Geom_CartesianPoint)::DownCast(myGeomPointB);
2047
2048       gp_Pln mygpPlane = myGeomPlane->Pln();
2049       gp_Ax1 thegpAxe = mygpPlane.Axis();
2050       gp_Dir theDir = thegpAxe.Direction();
2051       gp_Pnt theCenter = myCartPointB->Pnt();
2052       Standard_Real TheR = Draw::Atof(argv[4]);
2053       GC_MakeCircle Cir = GC_MakeCircle (theCenter, theDir ,TheR);
2054       Handle (Geom_Circle) theGeomCircle;
2055       try 
2056       {
2057         theGeomCircle = Cir.Value();
2058       }
2059       catch (StdFail_NotDone)
2060       {
2061         std::cout << "vcircle error: can't create circle\n";
2062         return -1; // TCL_ERROR
2063       }
2064
2065       DisplayCircle(theGeomCircle, aName, isFilled);
2066
2067     }
2068
2069     // Error
2070     else
2071     {
2072       std::cout << "vcircle error: 1st argument is a unexpected type.\n"; 
2073       return 1; // TCL_ERROR 
2074     }
2075
2076   }
2077   // No arguments: selection in the viewer
2078   // =========================================
2079   else 
2080   {
2081     // Get the name of the circle 
2082     TCollection_AsciiString aName(argv[1]);
2083
2084     TheAISContext()->OpenLocalContext();
2085     myCurrentIndex = TheAISContext()->IndexOfCurrentLocal();
2086
2087     // Activate selection mode for vertices and faces
2088     TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(1) );
2089     TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(4) );
2090     std::cout << " Select a vertex or a face\n";
2091
2092     // Wait for picking
2093     Standard_Integer argcc = 5;
2094     const char *buff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
2095     const char **argvv = (const char **) buff;
2096     while (ViewerMainLoop( argcc, argvv) ) { }
2097     // end of the loop
2098
2099     TopoDS_Shape ShapeA;
2100     for(TheAISContext()->InitSelected(); 
2101       TheAISContext()->MoreSelected(); 
2102       TheAISContext()->NextSelected() ) 
2103     {
2104       ShapeA = TheAISContext()->SelectedShape();
2105     }
2106
2107     // ShapeA is a Vertex
2108     if (ShapeA.ShapeType() == TopAbs_VERTEX ) 
2109     {
2110       TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(4) );
2111       std::cout << " Select a different vertex\n";
2112
2113       TopoDS_Shape ShapeB;
2114       do 
2115       {
2116         // Wait for picking
2117         Standard_Integer argccc = 5;
2118         const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
2119         const char **argvvv = (const char **) bufff;
2120         while (ViewerMainLoop( argccc, argvvv) ) { }
2121         // end of the loop
2122
2123         for(TheAISContext()->InitSelected(); 
2124           TheAISContext()->MoreSelected(); 
2125           TheAISContext()->NextSelected() ) 
2126         {
2127           ShapeB = TheAISContext()->SelectedShape();
2128         }
2129       } while(ShapeB.IsSame(ShapeA) );
2130
2131       // Selection of ShapeC
2132       std::cout << " Select the last vertex\n";
2133       TopoDS_Shape ShapeC;
2134       do 
2135       {
2136         // Wait for picking
2137         Standard_Integer argcccc = 5;
2138         const char *buffff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
2139         const char **argvvvv = (const char **) buffff;
2140         while (ViewerMainLoop( argcccc, argvvvv) ) { }
2141         // end of the loop
2142
2143         for(TheAISContext()->InitSelected(); 
2144           TheAISContext()->MoreSelected(); 
2145           TheAISContext()->NextSelected() ) 
2146         {
2147           ShapeC = TheAISContext()->SelectedShape();
2148         }
2149       } while(ShapeC.IsSame(ShapeA) || ShapeC.IsSame(ShapeB) );
2150       
2151       // Get isFilled
2152       Standard_Boolean isFilled;
2153       std::cout << "Enter filled status (0 or 1)\n";
2154       cin >> isFilled;
2155
2156       // Close the local context
2157       TheAISContext()->CloseLocalContext(myCurrentIndex);
2158
2159       // Construction of the circle
2160       gp_Pnt A = BRep_Tool::Pnt(TopoDS::Vertex(ShapeA));
2161       gp_Pnt B = BRep_Tool::Pnt(TopoDS::Vertex(ShapeB));
2162       gp_Pnt C = BRep_Tool::Pnt(TopoDS::Vertex(ShapeC));
2163
2164       GC_MakeCircle Cir = GC_MakeCircle (A, B, C);
2165       Handle (Geom_Circle) theGeomCircle;
2166       try 
2167       {
2168         theGeomCircle = Cir.Value();
2169       }
2170       catch (StdFail_NotDone)
2171       {
2172         std::cout << "vcircle error: can't create circle\n";
2173         return -1; // TCL_ERROR
2174       }
2175
2176       DisplayCircle(theGeomCircle, aName, isFilled);
2177
2178     }
2179     // Shape is a face
2180     else
2181     {
2182       std::cout << " Select a vertex (in your face)\n";
2183       TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(4) );
2184
2185       TopoDS_Shape ShapeB;
2186       // Wait for picking
2187       Standard_Integer argccc = 5;
2188       const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
2189       const char **argvvv = (const char **) bufff;
2190       while (ViewerMainLoop( argccc, argvvv) ) { }
2191       // end of the loop
2192
2193       for(TheAISContext()->InitSelected(); 
2194         TheAISContext()->MoreSelected(); 
2195         TheAISContext()->NextSelected() ) 
2196       {
2197         ShapeB = TheAISContext()->SelectedShape();
2198       }
2199
2200       // Recover the radius 
2201       Standard_Real theRad;
2202       do 
2203       {
2204         std::cout << " Enter the value of the radius:\n";
2205         cin >> theRad;
2206       } while (theRad <= 0);
2207       
2208       // Get filled status
2209       Standard_Boolean isFilled;
2210       std::cout << "Enter filled status (0 or 1)\n";
2211       cin >> isFilled;
2212
2213       // Close the local context
2214       TheAISContext()->CloseLocalContext(myCurrentIndex);
2215       // Construction of the circle
2216
2217       // Recover the normal to the plane. tag
2218       TopoDS_Face myFace = TopoDS::Face(ShapeA);
2219       BRepAdaptor_Surface mySurface (myFace, Standard_False);
2220       gp_Pln myPlane = mySurface.Plane();
2221       Handle(Geom_Plane) theGeomPlane = new Geom_Plane (myPlane);
2222       gp_Pln mygpPlane = theGeomPlane->Pln();
2223       gp_Ax1 thegpAxe = mygpPlane.Axis();
2224       gp_Dir theDir = thegpAxe.Direction();
2225
2226       // Recover the center
2227       gp_Pnt theCenter = BRep_Tool::Pnt(TopoDS::Vertex(ShapeB));
2228
2229       // Ñonstruct the circle
2230       GC_MakeCircle Cir = GC_MakeCircle (theCenter, theDir ,theRad);
2231       Handle (Geom_Circle) theGeomCircle;
2232       try 
2233       {
2234         theGeomCircle = Cir.Value();
2235       }
2236       catch (StdFail_NotDone)
2237       {
2238         std::cout << "vcircle error: can't create circle\n";
2239         return -1; // TCL_ERROR
2240       }
2241
2242       DisplayCircle(theGeomCircle, aName, isFilled);
2243       
2244     }
2245
2246   }
2247
2248   return 0;
2249 }
2250
2251
2252 //===============================================================================================
2253 //function : VDrawText
2254 //author   : psn
2255 //purpose  : Create a text.
2256 //Draw arg : vdrawtext  name  [X] [Y] [Z] [R] [G] [B] [hor_align] [ver_align] [angle] [zoomable]
2257 //===============================================================================================
2258 #include <Graphic3d_Group.hxx>
2259 #include <Graphic3d_Structure.hxx>
2260 #include <Graphic3d_AspectText3d.hxx>
2261 #include <Graphic3d_AspectFillArea3d.hxx>
2262 #include <Graphic3d_StructureManager.hxx>
2263 #include <Graphic3d_VerticalTextAlignment.hxx>
2264 #include <Graphic3d_HorizontalTextAlignment.hxx>
2265
2266 #include <Font_NameOfFont.hxx>
2267
2268 #include <Visual3d_ViewManager.hxx>
2269 #include <ViewerTest_Tool.ixx>
2270
2271 #include <Standard_DefineHandle.hxx>
2272
2273 #include <Prs3d_Root.hxx>
2274 #include <Prs3d_Text.hxx>
2275 #include <Prs3d_TextAspect.hxx>
2276 #include <Prs3d_ShadingAspect.hxx>
2277 #include <PrsMgr_PresentationManager3d.hxx>
2278
2279 #include <TCollection_ExtendedString.hxx>
2280 #include <TCollection_AsciiString.hxx>
2281
2282 #include <gp_Pnt.hxx>
2283 #include <Quantity_NameOfColor.hxx>
2284 #include <Quantity_Color.hxx>
2285
2286
2287 DEFINE_STANDARD_HANDLE(MyTextClass, AIS_InteractiveObject)
2288
2289 class MyTextClass:public AIS_InteractiveObject
2290 {
2291 public:
2292   // CASCADE RTTI
2293   DEFINE_STANDARD_RTTI(MyTextClass );
2294
2295   MyTextClass(){};
2296
2297   MyTextClass
2298     (
2299       const TCollection_ExtendedString& , const gp_Pnt& ,
2300       Quantity_Color color,
2301       Standard_Integer aHJust,
2302       Standard_Integer aVJust ,
2303       Standard_Real Angle ,
2304       Standard_Boolean Zoom ,
2305       Standard_Real  Height,
2306       Font_FontAspect FontAspect,
2307       Standard_CString Font
2308     );
2309
2310 private:
2311
2312   void Compute (  const Handle(PrsMgr_PresentationManager3d)& aPresentationManager,
2313                   const Handle(Prs3d_Presentation)& aPresentation,
2314                   const Standard_Integer aMode);
2315
2316   void ComputeSelection (  const Handle(SelectMgr_Selection)& /*aSelection*/,
2317                            const Standard_Integer /*aMode*/){} ;
2318
2319 protected:
2320   TCollection_ExtendedString          aText;
2321   gp_Pnt                              aPosition;
2322   Standard_Real                       Red;
2323   Standard_Real                       Green;
2324   Standard_Real                       Blue;
2325   Standard_Real                       aAngle;
2326   Standard_Real                       aHeight;
2327   Standard_Boolean                    aZoomable;
2328   Quantity_Color                      aColor;
2329   TCollection_AsciiString             aFont;
2330   Font_FontAspect                     aFontAspect;
2331   Graphic3d_HorizontalTextAlignment   aHJustification;
2332   Graphic3d_VerticalTextAlignment     aVJustification;
2333 };
2334
2335
2336
2337 IMPLEMENT_STANDARD_HANDLE(MyTextClass, AIS_InteractiveObject)
2338 IMPLEMENT_STANDARD_RTTIEXT(MyTextClass, AIS_InteractiveObject)
2339
2340
2341 MyTextClass::MyTextClass( const TCollection_ExtendedString& text, const gp_Pnt& position,
2342                           Quantity_Color    color       = Quantity_NOC_YELLOW,
2343                           Standard_Integer  aHJust      = Graphic3d_HTA_LEFT,
2344                           Standard_Integer  aVJust      = Graphic3d_VTA_BOTTOM,
2345                           Standard_Real     angle       = 0.0 ,
2346                           Standard_Boolean  zoomable    = Standard_True,
2347                           Standard_Real     height      = 12.,
2348                           Font_FontAspect   fontAspect  = Font_FA_Regular,
2349                           Standard_CString  font        = "Courier")
2350 {
2351   aText           = text;
2352   aPosition       = position;
2353   aHJustification = Graphic3d_HorizontalTextAlignment(aHJust);
2354   aVJustification = Graphic3d_VerticalTextAlignment(aVJust);
2355   aAngle          = angle;
2356   aZoomable       = zoomable;
2357   aHeight         = height;
2358   aColor          = color;
2359   aFontAspect     = fontAspect;
2360   aFont           = font;
2361 };
2362
2363
2364
2365 //////////////////////////////////////////////////////////////////////////////
2366 void MyTextClass::Compute(const Handle(PrsMgr_PresentationManager3d)& /*aPresentationManager*/,
2367                           const Handle(Prs3d_Presentation)& aPresentation,
2368                           const Standard_Integer /*aMode*/)
2369 {
2370
2371   aPresentation->Clear();
2372
2373   Handle_Prs3d_TextAspect asp = myDrawer->TextAspect();
2374
2375   asp->SetFont(aFont.ToCString());
2376   asp->SetColor(aColor);
2377   asp->SetHeight(aHeight); // I am changing the myHeight value
2378
2379   asp->SetHorizontalJustification(aHJustification);
2380   asp->SetVerticalJustification(aVJustification);
2381   asp->Aspect()->SetTextZoomable(aZoomable);
2382   asp->Aspect()->SetTextAngle(aAngle);
2383   asp->Aspect()->SetTextFontAspect(aFontAspect);
2384   Prs3d_Text::Draw(aPresentation, asp, aText, aPosition);
2385
2386   /* This comment code is worked
2387   Handle(Graphic3d_Group) TheGroup = Prs3d_Root::CurrentGroup(aPresentation);
2388   Handle(Graphic3d_AspectFillArea3d) aspect = myDrawer->ShadingAspect()->Aspect();
2389   Graphic3d_Vertex vertices_text;
2390   vertices_text.SetCoord(aPosition.X(),aPosition.Y(),aPosition.Y());
2391   TheGroup->SetPrimitivesAspect(aspect);
2392   TheGroup->Text(aText,vertices_text,aHeight,Standard_True);
2393   */
2394 };
2395
2396 static int VDrawText (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
2397 {
2398   // Check arguments
2399   if (argc < 14)
2400   {
2401     di<<"Error: "<<argv[0]<<" - invalid number of arguments\n";
2402     di<<"Usage: type help "<<argv[0]<<"\n";
2403     return 1; //TCL_ERROR
2404   }
2405
2406   Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
2407
2408   // Create 3D view if it doesn't exist
2409   if ( aContext.IsNull() )
2410   {
2411     ViewerTest::ViewerInit();
2412     aContext = ViewerTest::GetAISContext();
2413     if( aContext.IsNull() )
2414     {
2415       di << "Error: Cannot create a 3D view\n";
2416       return 1; //TCL_ERROR
2417     }
2418   }
2419
2420   // Text position
2421   const Standard_Real X = Draw::Atof(argv[2]);
2422   const Standard_Real Y = Draw::Atof(argv[3]);
2423   const Standard_Real Z = Draw::Atof(argv[4]);
2424   const gp_Pnt pnt(X,Y,Z);
2425
2426   // Text color
2427   const Quantity_Parameter R = Draw::Atof(argv[5])/255.;
2428   const Quantity_Parameter G = Draw::Atof(argv[6])/255.;
2429   const Quantity_Parameter B = Draw::Atof(argv[7])/255.;
2430   const Quantity_Color aColor( R, G, B, Quantity_TOC_RGB );
2431
2432   // Text alignment
2433   const int hor_align = Draw::Atoi(argv[8]);
2434   const int ver_align = Draw::Atoi(argv[9]);
2435
2436   // Text angle
2437   const Standard_Real angle = Draw::Atof(argv[10]);
2438
2439   // Text zooming
2440   const Standard_Boolean zoom = Draw::Atoi(argv[11]);
2441
2442   // Text height
2443   const Standard_Real height = Draw::Atof(argv[12]);
2444
2445   // Text aspect
2446   const Font_FontAspect aspect = Font_FontAspect(Draw::Atoi(argv[13]));
2447
2448   // Text font
2449   TCollection_AsciiString font;
2450   if(argc < 15)
2451     font.AssignCat("Courier");
2452   else
2453     font.AssignCat(argv[14]);
2454
2455   // Text is multibyte
2456   const Standard_Boolean isMultibyte = (argc < 16)? Standard_False : (Draw::Atoi(argv[15]) != 0);
2457
2458   // Read text string
2459   TCollection_ExtendedString name;
2460   if (isMultibyte)
2461   {
2462     const char *str = argv[1];
2463     while ( *str || *(str+1)=='\x0A' || *(str+1)=='\x0B' || *(str+1)=='\x0C' || *(str+1)=='\x0D'
2464                  || *(str+1)=='\x07' || *(str+1)=='\x08' || *(str+1)=='\x09' )
2465     {
2466       unsigned short c1 = *str++;
2467       unsigned short c2 = *str++;
2468       if (!c2) break;
2469       name += (Standard_ExtCharacter)((c1 << 8) | c2);
2470     }
2471   }
2472   else
2473   {
2474     name += argv[1];
2475   }
2476
2477   if (name.Length())
2478   {
2479     Handle(MyTextClass) myT = new MyTextClass(name,pnt,aColor,hor_align,ver_align,angle,zoom,height,aspect,font.ToCString());
2480     aContext->Display(myT,Standard_True);
2481   }
2482
2483   return 0;
2484 }
2485
2486 #include <math.h>
2487 #include <gp_Pnt.hxx>
2488 #include <Graphic3d_ArrayOfPoints.hxx>
2489 #include <Graphic3d_ArrayOfPrimitives.hxx>
2490 #include <Graphic3d_ArrayOfTriangles.hxx>
2491 #include <Poly_Array1OfTriangle.hxx>
2492 #include <Poly_Triangle.hxx>
2493 #include <Poly_Triangulation.hxx>
2494 #include <TColgp_Array1OfPnt.hxx>
2495 #include <TShort_Array1OfShortReal.hxx>
2496 #include <TShort_HArray1OfShortReal.hxx>
2497
2498 #include <AIS_Triangulation.hxx>
2499 #include <StdPrs_ToolShadedShape.hxx>
2500 #include <Poly_Connect.hxx>
2501 #include <TColgp_Array1OfDir.hxx>
2502 #include <Graphic3d_GraphicDriver.hxx>
2503
2504 #include <TColStd_Array1OfInteger.hxx>
2505 #include <TColStd_HArray1OfInteger.hxx>
2506 #include <Prs3d_ShadingAspect.hxx>
2507 #include <Graphic3d_MaterialAspect.hxx>
2508 #include <Graphic3d_AspectFillArea3d.hxx>
2509
2510 #include <BRepPrimAPI_MakeCylinder.hxx>
2511 #include <TopoDS_Shape.hxx>
2512 #include <TopExp_Explorer.hxx>
2513 #include <TopAbs.hxx>
2514 #include <StdSelect_ShapeTypeFilter.hxx>
2515
2516
2517 //===============================================================================================
2518 //function : CalculationOfSphere
2519 //author   : psn
2520 //purpose  : Create a Sphere
2521 //===============================================================================================
2522
2523 Handle( Poly_Triangulation ) CalculationOfSphere( double X , double Y , double Z ,
2524                                                   int res ,
2525                                                   double Radius ){
2526   double mRadius = Radius;
2527   double mCenter[3] = {X,Y,Z};
2528   int mThetaResolution;
2529   int mPhiResolution;
2530   double mStartTheta = 0;//StartTheta;
2531   double mEndTheta = 360;//EndTheta;
2532   double mStartPhi = 0;//StartPhi;
2533   double mEndPhi = 180;//EndPhi;
2534   res = res < 4 ? 4 : res;
2535
2536   mThetaResolution = res;
2537   mPhiResolution = res;
2538
2539   int i, j;
2540   int jStart, jEnd, numOffset;
2541   int numPts, numPolys;
2542   double x[3], n[3], deltaPhi, deltaTheta, phi, theta, radius;
2543   double startTheta, endTheta, startPhi, endPhi;
2544   int base, numPoles=0, thetaResolution, phiResolution;
2545
2546   int pts[3];
2547   int piece = -1;
2548   int numPieces = 1;
2549   if ( numPieces > mThetaResolution ) {
2550     numPieces = mThetaResolution;
2551   }
2552
2553   int localThetaResolution =  mThetaResolution;
2554   double localStartTheta =  mStartTheta;
2555   double localEndTheta =  mEndTheta;
2556
2557   while ( localEndTheta < localStartTheta ) {
2558     localEndTheta += 360.0;
2559   }
2560
2561   deltaTheta = (localEndTheta - localStartTheta) / localThetaResolution;
2562
2563   // Change the ivars based on pieces.
2564   int start, end;
2565   start = piece * localThetaResolution / numPieces;
2566   end = (piece+1) * localThetaResolution / numPieces;
2567   localEndTheta = localStartTheta + (double)(end) * deltaTheta;
2568   localStartTheta = localStartTheta + (double)(start) * deltaTheta;
2569   localThetaResolution = end - start;
2570
2571   numPts =  mPhiResolution * localThetaResolution + 2;
2572   numPolys =  mPhiResolution * 2 * localThetaResolution;
2573
2574   // Create north pole if needed
2575   int number_point = 0;
2576   int number_pointArray = 0;
2577
2578   if ( mStartPhi <= 0.0 ) {
2579     number_pointArray++;
2580     numPoles++;
2581   }
2582   if ( mEndPhi >= 180.0 ) {
2583     number_pointArray++;
2584     numPoles++;
2585   }
2586
2587   // Check data, determine increments, and convert to radians
2588   startTheta = (localStartTheta < localEndTheta ? localStartTheta : localEndTheta);
2589   startTheta *= M_PI  / 180.0;
2590   endTheta = (localEndTheta > localStartTheta ? localEndTheta : localStartTheta);
2591   endTheta *= M_PI  / 180.0;
2592
2593
2594   startPhi = ( mStartPhi <  mEndPhi ?  mStartPhi :  mEndPhi);
2595   startPhi *= M_PI  / 180.0;
2596   endPhi = ( mEndPhi >  mStartPhi ?  mEndPhi :  mStartPhi);
2597   endPhi *= M_PI  / 180.0;
2598
2599   phiResolution =  mPhiResolution - numPoles;
2600   deltaPhi = (endPhi - startPhi) / ( mPhiResolution - 1);
2601   thetaResolution = localThetaResolution;
2602   if ( fabs(localStartTheta - localEndTheta) < 360.0 ) {
2603     ++localThetaResolution;
2604   }
2605   deltaTheta = (endTheta - startTheta) / thetaResolution;
2606
2607   jStart = ( mStartPhi <= 0.0 ? 1 : 0);
2608   jEnd = ( mEndPhi >= 180.0 ?  mPhiResolution - 1 :  mPhiResolution);
2609
2610   // Create intermediate points
2611   for ( i = 0; i < localThetaResolution; i++ ) {
2612     for ( j = jStart; j < jEnd; j++ ) {
2613         number_pointArray++;
2614     }
2615   }
2616
2617   //Generate mesh connectivity
2618   base = phiResolution * localThetaResolution;
2619
2620   int number_triangle = 0 ;
2621   if ( mStartPhi <= 0.0 ) { // around north pole
2622     number_triangle += localThetaResolution;
2623   }
2624
2625   if ( mEndPhi >= 180.0 ) { // around south pole
2626     number_triangle += localThetaResolution;
2627   }
2628
2629   // bands in-between poles
2630   for ( i=0; i < localThetaResolution; i++){
2631     for ( j=0; j < (phiResolution-1); j++){
2632        number_triangle +=2;
2633     }
2634   }
2635
2636   Handle( Poly_Triangulation ) polyTriangulation = new Poly_Triangulation(number_pointArray, number_triangle, false);
2637   TColgp_Array1OfPnt& PointsOfArray = polyTriangulation->ChangeNodes();
2638   Poly_Array1OfTriangle& pArrayTriangle = polyTriangulation->ChangeTriangles();
2639
2640   if (  mStartPhi <= 0.0 ){
2641       x[0] =  mCenter[0];
2642       x[1] =  mCenter[1];
2643       x[2] =  mCenter[2] +  mRadius;
2644       PointsOfArray.SetValue(1,gp_Pnt(x[0],x[1],x[2]));
2645   }
2646
2647   // Create south pole if needed
2648   if (  mEndPhi >= 180.0 ){
2649       x[0] =  mCenter[0];
2650       x[1] =  mCenter[1];
2651       x[2] =  mCenter[2] -  mRadius;
2652       PointsOfArray.SetValue(2,gp_Pnt(x[0],x[1],x[2]));
2653   }
2654
2655   number_point = 3;
2656   for ( i=0; i < localThetaResolution; i++){
2657     theta = localStartTheta * M_PI / 180.0 + i*deltaTheta;
2658     for ( j = jStart; j < jEnd; j++){
2659         phi = startPhi + j*deltaPhi;
2660         radius =  mRadius * sin((double)phi);
2661         n[0] = radius * cos((double)theta);
2662         n[1] = radius * sin((double)theta);
2663         n[2] =  mRadius * cos((double)phi);
2664         x[0] = n[0] +  mCenter[0];
2665         x[1] = n[1] +  mCenter[1];
2666         x[2] = n[2] +  mCenter[2];
2667         PointsOfArray.SetValue(number_point,gp_Pnt(x[0],x[1],x[2]));
2668         number_point++;
2669       }
2670     }
2671
2672   numPoles = 3;
2673   number_triangle = 1;
2674   if ( mStartPhi <= 0.0 ){// around north pole
2675     for (i=0; i < localThetaResolution; i++){
2676         pts[0] = phiResolution*i + numPoles;
2677         pts[1] = (phiResolution*(i+1) % base) + numPoles;
2678         pts[2] = 1;
2679         pArrayTriangle.SetValue(number_triangle,Poly_Triangle(pts[0],pts[1],pts[2]));
2680         number_triangle++;
2681       }
2682     }
2683
2684   if (  mEndPhi >= 180.0 ){ // around south pole
2685     numOffset = phiResolution - 1 + numPoles;
2686     for (i=0; i < localThetaResolution; i++){
2687         pts[0] = phiResolution*i + numOffset;
2688         pts[2] = ((phiResolution*(i+1)) % base) + numOffset;
2689         pts[1] = numPoles - 1;
2690         pArrayTriangle.SetValue(number_triangle,Poly_Triangle(pts[0],pts[1],pts[2]));
2691         number_triangle++;
2692       }
2693     }
2694
2695   // bands in-between poles
2696
2697   for (i=0; i < localThetaResolution; i++){
2698     for (j=0; j < (phiResolution-1); j++){
2699         pts[0] = phiResolution*i + j + numPoles;
2700         pts[1] = pts[0] + 1;
2701         pts[2] = ((phiResolution*(i+1)+j) % base) + numPoles + 1;
2702         pArrayTriangle.SetValue(number_triangle,Poly_Triangle(pts[0],pts[1],pts[2]));
2703         number_triangle++;
2704         pts[1] = pts[2];
2705         pts[2] = pts[1] - 1;
2706         pArrayTriangle.SetValue(number_triangle,Poly_Triangle(pts[0],pts[1],pts[2]));
2707         number_triangle++;
2708       }
2709     }
2710
2711   Poly_Connect* pc = new Poly_Connect(polyTriangulation);
2712
2713   Handle(TShort_HArray1OfShortReal) Normals = new TShort_HArray1OfShortReal(1, polyTriangulation->NbNodes() * 3);
2714
2715   Standard_Integer index[3];
2716   Standard_Real Tol = Precision::Confusion();
2717
2718   gp_Dir Nor;
2719   for (i = PointsOfArray.Lower(); i <= PointsOfArray.Upper(); i++) {
2720       gp_XYZ eqPlan(0, 0, 0);
2721       for ( pc->Initialize(i); pc->More(); pc->Next()) {
2722         pArrayTriangle(pc->Value()).Get(index[0], index[1], index[2]);
2723         gp_XYZ v1(PointsOfArray(index[1]).Coord()-PointsOfArray(index[0]).Coord());
2724         gp_XYZ v2(PointsOfArray(index[2]).Coord()-PointsOfArray(index[1]).Coord());
2725         gp_XYZ vv = v1^v2;
2726         Standard_Real mod = vv.Modulus();
2727         if(mod < Tol) continue;
2728         eqPlan += vv/mod;
2729       }
2730
2731       Standard_Real modmax = eqPlan.Modulus();
2732
2733       if(modmax > Tol)
2734         Nor = gp_Dir(eqPlan);
2735       else
2736         Nor = gp_Dir(0., 0., 1.);
2737
2738       Standard_Integer j = (i - PointsOfArray.Lower()) * 3;
2739       Normals->SetValue(j + 1, (Standard_ShortReal)Nor.X());
2740       Normals->SetValue(j + 2, (Standard_ShortReal)Nor.Y());
2741       Normals->SetValue(j + 3, (Standard_ShortReal)Nor.Z());
2742   }
2743
2744   delete pc;
2745   polyTriangulation->SetNormals(Normals);
2746
2747   return polyTriangulation;
2748 }
2749
2750 //===============================================================================================
2751 //function : VDrawSphere
2752 //author   : psn
2753 //purpose  : Create an AIS shape.
2754 //===============================================================================================
2755 static int VDrawSphere (Draw_Interpretor& /*di*/, Standard_Integer argc, const char** argv)
2756 {
2757   // check for errors
2758   Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext();
2759   if (aContextAIS.IsNull())
2760   {
2761     std::cout << "Call vinit before!\n";
2762     return 1;
2763   }
2764   else if (argc < 3)
2765   {
2766     std::cout << "Use: " << argv[0]
2767               << " shapeName Fineness [X=0.0 Y=0.0 Z=0.0] [Radius=100.0] [ToShowEdges=0]\n";
2768     return 1;
2769   }
2770
2771   // read the arguments
2772   TCollection_AsciiString aShapeName (argv[1]);
2773   Standard_Integer aResolution = Draw::Atoi (argv[2]);
2774   Standard_Real aCenterX = (argc > 5) ? Draw::Atof (argv[3]) : 0.0;
2775   Standard_Real aCenterY = (argc > 5) ? Draw::Atof (argv[4]) : 0.0;
2776   Standard_Real aCenterZ = (argc > 5) ? Draw::Atof (argv[5]) : 0.0;
2777   Standard_Real aRadius =  (argc > 6) ? Draw::Atof (argv[6]) : 100.0;
2778   Standard_Boolean toShowEdges =  (argc > 7) ? Draw::Atoi (argv[7]) : Standard_False;
2779
2780   // remove AIS object with given name from map
2781   VDisplayAISObject (aShapeName, Handle(AIS_InteractiveObject)());
2782
2783   std::cout << "Compute Triangulation...\n";
2784   Handle(AIS_Triangulation) aShape
2785     = new AIS_Triangulation (CalculationOfSphere (aCenterX, aCenterY, aCenterZ,
2786                                                   aResolution,
2787                                                   aRadius));
2788   Standard_Integer aNumberPoints    = aShape->GetTriangulation()->Nodes().Length();
2789   Standard_Integer aNumberTriangles = aShape->GetTriangulation()->Triangles().Length();
2790
2791   // stupid initialization of Green color in RGBA space as integer
2792   // probably wrong for big-endian CPUs
2793   Standard_Integer aRed    = 0;
2794   Standard_Integer aGreen  = 255;
2795   Standard_Integer aBlue   = 0;
2796   Standard_Integer anAlpha = 0; // not used
2797   Standard_Integer aColorInt = aRed;
2798   aColorInt += aGreen  << 8;
2799   aColorInt += aBlue   << 16;
2800   aColorInt += anAlpha << 24;
2801
2802   // setup colors array per vertex
2803   Handle(TColStd_HArray1OfInteger) aColorArray = new TColStd_HArray1OfInteger (1, aNumberPoints);
2804   for (Standard_Integer aNodeId = 1; aNodeId <= aNumberPoints; ++aNodeId)
2805   {
2806     aColorArray->SetValue (aNodeId, aColorInt);
2807   }
2808   aShape->SetColors (aColorArray);
2809
2810   // show statistics
2811   Standard_Integer aPointsSize      = aNumberPoints * 3 * sizeof(float);  // 3x GLfloat
2812   Standard_Integer aNormalsSize     = aNumberPoints * 3 * sizeof(float);  // 3x GLfloat
2813   Standard_Integer aColorsSize      = aNumberPoints * 3 * sizeof(float);  // 3x GLfloat without alpha
2814   Standard_Integer aTrianglesSize   = aNumberTriangles * 3 * sizeof(int); // 3x GLint
2815   Standard_Integer aPolyConnectSize = aNumberPoints * 4 + aNumberTriangles * 6 * 4;
2816   Standard_Integer aTotalSize       = aPointsSize + aNormalsSize + aColorsSize + aTrianglesSize;
2817   aTotalSize >>= 20; //MB
2818   aNormalsSize >>= 20;
2819   aColorsSize >>= 20;
2820   aTrianglesSize >>= 20;
2821   aPolyConnectSize >>= 20;
2822   std::cout << "NumberOfPoints:    " << aNumberPoints << "\n"
2823             << "NumberOfTriangles: " << aNumberTriangles << "\n"
2824             << "Amount of memory required for PolyTriangulation without Normals: " << (aTotalSize - aNormalsSize) << " Mb\n"
2825             << "Amount of memory for colors: " << aColorsSize << " Mb\n"
2826             << "Amount of memory for PolyConnect: " << aPolyConnectSize << " Mb\n"
2827             << "Amount of graphic card memory required: " << aTotalSize << " Mb\n";
2828
2829   // Setting material properties, very important for desirable visual result!
2830   Graphic3d_MaterialAspect aMat (Graphic3d_NOM_PLASTIC);
2831   aMat.SetAmbient (0.2);
2832   aMat.SetSpecular (0.5);
2833   Handle(Graphic3d_AspectFillArea3d) anAspect
2834     = new Graphic3d_AspectFillArea3d (Aspect_IS_SOLID,
2835                                       Quantity_NOC_RED,
2836                                       Quantity_NOC_YELLOW,
2837                                       Aspect_TOL_SOLID,
2838                                       1.0,
2839                                       aMat,
2840                                       aMat);
2841   Handle(Prs3d_ShadingAspect) aShAsp = new Prs3d_ShadingAspect();
2842   if (toShowEdges)
2843   {
2844     anAspect->SetEdgeOn();
2845   }
2846   else
2847   {
2848     anAspect->SetEdgeOff();
2849   }
2850   aShAsp->SetAspect (anAspect);
2851   aShape->Attributes()->SetShadingAspect (aShAsp);
2852
2853   VDisplayAISObject (aShapeName, aShape);
2854   return 0;
2855 }
2856
2857 //=============================================================================
2858 //function : VComputeHLR
2859 //purpose  :
2860 //=============================================================================
2861
2862 static int VComputeHLR (Draw_Interpretor& di,
2863                         Standard_Integer argc,
2864                         const char** argv)
2865 {
2866   Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext ();
2867
2868   if (aContextAIS.IsNull ())
2869   {
2870     di << "Please call vinit before\n";
2871     return 1;
2872   }
2873
2874   if ( argc != 3 &&  argc != 12 )
2875   {
2876     di << "Usage: " << argv[0] << " ShapeName HlrName "
2877        << "[ eye_x eye_y eye_z dir_x dir_y dir_z upx upy upz ]" << "\n"
2878        << "                    ShapeName - name of the initial shape\n"
2879        << "                    HlrName - result hlr object from initial shape\n"
2880        << "                    eye, dir are eye position and look direction\n"
2881        << "                    up is the look up direction vector\n"
2882        << "                    Use vtop to see projected hlr shape\n";
2883     return 1;
2884   }
2885
2886   // shape and new object name
2887   TCollection_AsciiString aShapeName (argv[1]);
2888   TCollection_AsciiString aHlrName (argv[2]);
2889
2890   TopoDS_Shape aSh = DBRep::Get (argv[1]);
2891   if (aSh.IsNull()) 
2892   {
2893     BRep_Builder aBrepBuilder;
2894     BRepTools::Read (aSh, argv[1], aBrepBuilder);
2895     if (aSh.IsNull ())
2896     {
2897       di << "No shape with name " << argv[1] << " found\n";
2898       return 1;
2899     }
2900   }
2901
2902   if (GetMapOfAIS ().IsBound2 (aHlrName))
2903   {
2904     di << "Presentable object with name " << argv[2] << " already exists\n";
2905     return 1;
2906   }
2907
2908   // close local context
2909   if (aContextAIS->HasOpenedContext ())
2910     aContextAIS->CloseLocalContext ();
2911
2912   Handle(HLRBRep_PolyAlgo) aPolyAlgo = new HLRBRep_PolyAlgo();
2913   HLRBRep_PolyHLRToShape aHLRToShape;
2914
2915   gp_Pnt anEye;
2916   gp_Dir aDir;
2917   gp_Ax2 aProjAx;
2918   if (argc == 9)
2919   {
2920     gp_Dir anUp;
2921
2922     anEye.SetCoord (Draw::Atof (argv[3]), Draw::Atof (argv[4]), Draw::Atof (argv[5]));
2923     aDir.SetCoord (Draw::Atof (argv[6]), Draw::Atof (argv[7]), Draw::Atof (argv[8]));
2924     anUp.SetCoord (Draw::Atof (argv[9]), Draw::Atof (argv[10]), Draw::Atof (argv[11]));
2925     aProjAx.SetLocation (anEye);
2926     aProjAx.SetDirection (aDir);
2927     aProjAx.SetYDirection (anUp);
2928   }
2929   else
2930   {
2931     gp_Dir aRight;
2932
2933     Handle(V3d_Viewer) aViewer = ViewerTest::GetViewerFromContext();
2934     Handle(V3d_View)   aView   = ViewerTest::CurrentView();
2935     Standard_Integer aWidth, aHeight;
2936     Standard_Real aCentX, aCentY, aCentZ, aDirX, aDirY, aDirZ;
2937     Standard_Real aRightX, aRightY, aRightZ;
2938     aView->Window()->Size (aWidth, aHeight);
2939
2940     aView->ConvertWithProj (aWidth, aHeight/2, 
2941                             aRightX, aRightY, aRightZ,
2942                             aDirX, aDirY, aDirZ);
2943
2944     aView->ConvertWithProj (aWidth/2, aHeight/2, 
2945                             aCentX, aCentY, aCentZ,
2946                             aDirX, aDirY, aDirZ);
2947
2948     anEye.SetCoord (-aCentX, -aCentY, -aCentZ);
2949     aDir.SetCoord (-aDirX, -aDirY, -aDirZ);
2950     aRight.SetCoord (aRightX - aCentX, aRightY - aCentY, aRightZ - aCentZ);
2951     aProjAx.SetLocation (anEye);
2952     aProjAx.SetDirection (aDir);
2953     aProjAx.SetXDirection (aRight);
2954   }
2955
2956   HLRAlgo_Projector aProjector (aProjAx);
2957   aPolyAlgo->Projector (aProjector);
2958   aPolyAlgo->Load (aSh);
2959   aPolyAlgo->Update ();
2960
2961   aHLRToShape.Update (aPolyAlgo);
2962
2963   // make hlr shape from input shape
2964   TopoDS_Compound aHlrShape;
2965   BRep_Builder aBuilder;
2966   aBuilder.MakeCompound (aHlrShape);
2967
2968   TopoDS_Shape aCompound = aHLRToShape.VCompound();
2969   if (!aCompound.IsNull ())
2970   {
2971     aBuilder.Add (aHlrShape, aCompound);
2972   }
2973   
2974   // extract visible outlines
2975   aCompound = aHLRToShape.OutLineVCompound();
2976   if (!aCompound.IsNull ())
2977   {
2978     aBuilder.Add (aHlrShape, aCompound);
2979   }
2980
2981   // create an AIS shape and display it
2982   Handle(AIS_Shape) anObject = new AIS_Shape (aHlrShape);
2983   GetMapOfAIS().Bind (anObject, aHlrName);
2984   aContextAIS->Display (anObject);
2985
2986   aContextAIS->UpdateCurrentViewer ();
2987
2988   return 0;
2989 }
2990
2991 // This class is a wrap for Graphic3d_ArrayOfPrimitives; it is used for
2992 // manipulating and displaying such an array with AIS context
2993 DEFINE_STANDARD_HANDLE(MyPArrayObject, AIS_InteractiveObject)
2994 class MyPArrayObject : public AIS_InteractiveObject
2995 {
2996
2997 public:
2998
2999   MyPArrayObject (Handle(TColStd_HArray1OfAsciiString) theArrayDescription,
3000                   Handle(Graphic3d_AspectMarker3d) theMarkerAspect = NULL)
3001   {
3002     myArrayDescription = theArrayDescription;
3003     myMarkerAspect = theMarkerAspect;
3004   }
3005
3006   DEFINE_STANDARD_RTTI(MyPArrayObject);
3007
3008 private:
3009
3010   void Compute (const Handle(PrsMgr_PresentationManager3d)& aPresentationManager,
3011                 const Handle(Prs3d_Presentation)& aPresentation,
3012                 const Standard_Integer aMode);
3013
3014   void ComputeSelection (const Handle(SelectMgr_Selection)& theSelection,
3015                          const Standard_Integer /*theMode*/);
3016
3017   bool CheckInputCommand (const TCollection_AsciiString theCommand,
3018                           const Handle(TColStd_HArray1OfAsciiString) theArgsArray,
3019                           Standard_Integer &theArgIndex,
3020                           Standard_Integer theArgCount,
3021                           Standard_Integer theMaxArgs);
3022
3023 protected:
3024
3025   Handle(TColStd_HArray1OfAsciiString) myArrayDescription;
3026   Handle(Graphic3d_AspectMarker3d) myMarkerAspect;
3027
3028 };
3029
3030 IMPLEMENT_STANDARD_HANDLE(MyPArrayObject, AIS_InteractiveObject)
3031 IMPLEMENT_STANDARD_RTTIEXT(MyPArrayObject, AIS_InteractiveObject)
3032
3033 void MyPArrayObject::Compute (const Handle(PrsMgr_PresentationManager3d)& /*aPresentationManager*/,
3034                               const Handle(Prs3d_Presentation)& aPresentation,
3035                               const Standard_Integer /*aMode*/)
3036 {
3037
3038   // Parsing array description
3039   Standard_Integer aVertexNum = 0, aBoundNum = 0, aEdgeNum = 0;
3040   Standard_Boolean hasVColors, hasBColors, hasNormals, hasInfos, hasTexels;
3041   hasVColors = hasNormals = hasBColors = hasInfos = hasTexels = Standard_False;
3042
3043   Standard_Integer anArgIndex = 0;
3044   Standard_Integer anArgsCount = myArrayDescription->Length();
3045   TCollection_AsciiString anArrayType = myArrayDescription->Value (anArgIndex++);
3046
3047   TCollection_AsciiString aCommand;
3048   while (anArgIndex < anArgsCount)
3049   {
3050     aCommand = myArrayDescription->Value (anArgIndex);
3051     aCommand.LowerCase();
3052
3053     // vertex command
3054     if (CheckInputCommand ("v", myArrayDescription, anArgIndex, 3, anArgsCount))
3055     {
3056       // vertex has a normal or normal with color or texel
3057       if (CheckInputCommand ("n", myArrayDescription, anArgIndex, 3, anArgsCount))
3058         hasNormals = Standard_True;
3059
3060       // vertex has a color
3061       if (CheckInputCommand ("c", myArrayDescription, anArgIndex, 3, anArgsCount))
3062         hasVColors = Standard_True;
3063
3064       // vertex has a texel
3065       if (CheckInputCommand ("t", myArrayDescription, anArgIndex, 2, anArgsCount))
3066         hasTexels = Standard_True;
3067
3068       aVertexNum++;
3069     }
3070     // bound command
3071     else if (CheckInputCommand ("b", myArrayDescription, anArgIndex, 1, anArgsCount))
3072     {
3073       // bound has color
3074       if (CheckInputCommand ("c", myArrayDescription, anArgIndex, 3, anArgsCount))
3075         hasBColors = Standard_True;
3076
3077       aBoundNum++;
3078     }
3079     // edge command
3080     else if (CheckInputCommand ("e", myArrayDescription, anArgIndex, 1, anArgsCount))
3081     {
3082       // edge has a hide flag
3083       if (CheckInputCommand ("h", myArrayDescription, anArgIndex, 0, anArgsCount))
3084         hasInfos = Standard_True;
3085
3086       aEdgeNum++;
3087     }
3088     // unknown command
3089     else
3090       anArgIndex++;
3091   }
3092
3093   Handle(Graphic3d_ArrayOfPrimitives) anArray;
3094   if (anArrayType == "points")
3095   {
3096     anArray = new Graphic3d_ArrayOfPoints (aVertexNum);
3097   }
3098   else if (anArrayType == "segments")
3099     anArray = new Graphic3d_ArrayOfSegments (aVertexNum, aEdgeNum, hasVColors);
3100   else if (anArrayType == "polylines")
3101     anArray = new Graphic3d_ArrayOfPolylines (aVertexNum, aBoundNum, aEdgeNum,
3102                                               hasVColors, hasBColors, hasInfos);
3103   else if (anArrayType == "triangles")
3104     anArray = new Graphic3d_ArrayOfTriangles (aVertexNum, aEdgeNum, hasNormals,
3105                                               hasVColors, hasTexels, hasInfos);
3106   else if (anArrayType == "trianglefans")
3107     anArray = new Graphic3d_ArrayOfTriangleFans (aVertexNum, aBoundNum,
3108                                                  hasNormals, hasVColors,
3109                                                  hasBColors, hasTexels);
3110   else if (anArrayType == "trianglestrips")
3111     anArray = new Graphic3d_ArrayOfTriangleStrips (aVertexNum, aBoundNum,
3112                                                    hasNormals, hasVColors,
3113                                                    hasBColors, hasTexels);
3114   else if (anArrayType == "quads")
3115     anArray = new Graphic3d_ArrayOfQuadrangles (aVertexNum, aEdgeNum,
3116                                                 hasNormals, hasVColors,
3117                                                 hasTexels, hasInfos);
3118   else if (anArrayType == "quadstrips")
3119     anArray = new Graphic3d_ArrayOfQuadrangleStrips (aVertexNum, aBoundNum,
3120                                                      hasNormals, hasVColors,
3121                                                      hasBColors, hasTexels);
3122   else if (anArrayType == "polygons")
3123     anArray = new Graphic3d_ArrayOfPolygons (aVertexNum, aBoundNum, aEdgeNum,
3124                                              hasNormals, hasVColors, hasBColors,
3125                                              hasTexels, hasInfos);
3126
3127   anArgIndex = 1;
3128   while (anArgIndex < anArgsCount)
3129   {
3130     aCommand = myArrayDescription->Value (anArgIndex);
3131     aCommand.LowerCase();
3132     if (!aCommand.IsAscii())
3133       break;
3134
3135     // vertex command
3136     if (CheckInputCommand ("v", myArrayDescription, anArgIndex, 3, anArgsCount))
3137     {
3138       anArray->AddVertex (myArrayDescription->Value (anArgIndex - 3).RealValue(),
3139                           myArrayDescription->Value (anArgIndex - 2).RealValue(),
3140                           myArrayDescription->Value (anArgIndex - 1).RealValue());
3141
3142       // vertex has a normal or normal with color or texel
3143       if (CheckInputCommand ("n", myArrayDescription, anArgIndex, 3, anArgsCount))
3144         anArray->SetVertexNormal (anArray->VertexNumber (),
3145                                   myArrayDescription->Value (anArgIndex - 3).RealValue(),
3146                                   myArrayDescription->Value (anArgIndex - 2).RealValue(),
3147                                   myArrayDescription->Value (anArgIndex - 1).RealValue());
3148       
3149       if (CheckInputCommand ("c", myArrayDescription, anArgIndex, 3, anArgsCount))
3150         anArray->SetVertexColor (anArray->VertexNumber (),
3151                                  myArrayDescription->Value (anArgIndex - 3).RealValue(),
3152                                  myArrayDescription->Value (anArgIndex - 2).RealValue(),
3153                                  myArrayDescription->Value (anArgIndex - 1).RealValue());
3154       
3155       if (CheckInputCommand ("t", myArrayDescription, anArgIndex, 2, anArgsCount))
3156         anArray->SetVertexTexel (anArray->VertexNumber (),
3157                                  myArrayDescription->Value (anArgIndex - 2).RealValue(),
3158                                  myArrayDescription->Value (anArgIndex - 1).RealValue());
3159     }
3160     // bounds command
3161     else if (CheckInputCommand ("b", myArrayDescription, anArgIndex, 1, anArgsCount))
3162     {
3163       Standard_Integer aVertCount = myArrayDescription->Value (anArgIndex - 1).IntegerValue();
3164
3165       if (CheckInputCommand ("c", myArrayDescription, anArgIndex, 3, anArgsCount))
3166         anArray->AddBound (aVertCount,
3167                            myArrayDescription->Value (anArgIndex - 3).RealValue(),
3168                            myArrayDescription->Value (anArgIndex - 2).RealValue(),
3169                            myArrayDescription->Value (anArgIndex - 1).RealValue());
3170
3171       else
3172         anArray->AddBound (aVertCount);
3173     }
3174     // edge command
3175     else if (CheckInputCommand ("e", myArrayDescription, anArgIndex, 1, anArgsCount))
3176     {
3177       Standard_Integer aVertIndex = myArrayDescription->Value (anArgIndex - 1).IntegerValue();
3178
3179       // edge has/hasn't hide flag
3180       if (CheckInputCommand ("h", myArrayDescription, anArgIndex, 0, anArgsCount))
3181         anArray->AddEdge (aVertIndex, Standard_False);
3182       else
3183         anArray->AddEdge (aVertIndex, Standard_True);
3184     }
3185     // unknown command
3186     else
3187       anArgIndex++;
3188   }
3189
3190   aPresentation->Clear();
3191   if (!myMarkerAspect.IsNull())
3192   {
3193     Prs3d_Root::CurrentGroup (aPresentation)->SetGroupPrimitivesAspect (myMarkerAspect);
3194   }
3195   Prs3d_Root::CurrentGroup (aPresentation)->AddPrimitiveArray (anArray);
3196 }
3197
3198 void MyPArrayObject::ComputeSelection (const Handle(SelectMgr_Selection)& theSelection,
3199                                        const Standard_Integer /*theMode*/)
3200 {
3201   Handle(SelectMgr_EntityOwner) anEntityOwner = new SelectMgr_EntityOwner (this);
3202
3203   Standard_Integer anArgIndex = 1;
3204   while (anArgIndex < myArrayDescription->Length())
3205   {
3206     if (CheckInputCommand ("v", myArrayDescription, anArgIndex, 3, myArrayDescription->Length()))
3207     {
3208       gp_Pnt aPoint (myArrayDescription->Value (anArgIndex - 3).RealValue(),
3209                      myArrayDescription->Value (anArgIndex - 2).RealValue(),
3210                      myArrayDescription->Value (anArgIndex - 1).RealValue());
3211       Handle(Select3D_SensitivePoint) aSensetivePoint = new Select3D_SensitivePoint (anEntityOwner, aPoint);
3212       theSelection->Add (aSensetivePoint);
3213     }
3214     else
3215     {
3216       anArgIndex++;
3217     }
3218   }
3219 }
3220
3221 bool MyPArrayObject::CheckInputCommand (const TCollection_AsciiString theCommand,
3222                                        const Handle(TColStd_HArray1OfAsciiString) theArgsArray,
3223                                        Standard_Integer &theArgIndex,
3224                                        Standard_Integer theArgCount,
3225                                        Standard_Integer theMaxArgs)
3226 {
3227   // check if there is more elements than expected
3228   if (theArgIndex >= theMaxArgs)
3229     return false;
3230
3231   TCollection_AsciiString aStrCommand = theArgsArray->Value (theArgIndex);
3232   aStrCommand.LowerCase();
3233   if (aStrCommand.Search(theCommand) != 1 ||
3234       theArgIndex + (theArgCount - 1) >= theMaxArgs)
3235     return false;
3236
3237   // go to the first data element
3238   theArgIndex++;
3239
3240   // check data if it can be converted to numeric
3241   for (int aElement = 0; aElement < theArgCount; aElement++, theArgIndex++)
3242   {
3243     aStrCommand = theArgsArray->Value (theArgIndex);
3244     if (!aStrCommand.IsRealValue())
3245       return false;
3246   }
3247
3248   return true;
3249 }
3250
3251 //=============================================================================
3252 //function : VDrawPArray
3253 //purpose  : Draws primitives array from list of vertexes, bounds, edges
3254 //=============================================================================
3255
3256 static int VDrawPArray (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
3257 {
3258   Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext();
3259   if (aContextAIS.IsNull())
3260   {
3261     di << "Call vinit before!\n";
3262     return 1;
3263   }
3264   else if (argc < 3)
3265   {
3266     di << "Use: " << argv[0] << " Name TypeOfArray"
3267        << " [vertex] ... [bounds] ... [edges]\n"
3268        << "  TypeOfArray={ points | segments | polylines | triangles |\n"
3269        << "                trianglefans | trianglestrips | quads |\n"
3270        << "                quadstrips | polygons }\n"
3271        << "  vertex={ 'v' x y z [normal={ 'n' nx ny nz }] [color={ 'c' r g b }]"
3272        << " [texel={ 't' tx ty }] } \n"
3273        << "  bounds={ 'b' verticies_count [color={ 'c' r g b }] }\n"
3274        << "  edges={ 'e' vertex_id [hidden_edge={'h'}] }\n";
3275     return 1;
3276   }
3277
3278   // read the arguments
3279   Standard_Integer aArgIndex = 1;
3280   TCollection_AsciiString aName (argv[aArgIndex++]);
3281   TCollection_AsciiString anArrayType (argv[aArgIndex++]);
3282
3283   Standard_Boolean hasVertex = Standard_False;
3284
3285   Handle(TColStd_HArray1OfAsciiString) anArgsArray = new TColStd_HArray1OfAsciiString (0, argc - 2);
3286   anArgsArray->SetValue (0, anArrayType);
3287
3288   if (anArrayType != "points"         &&
3289       anArrayType != "segments"       &&
3290       anArrayType != "polylines"      &&
3291       anArrayType != "triangles"      &&
3292       anArrayType != "trianglefans"   &&
3293       anArrayType != "trianglestrips" &&
3294       anArrayType != "quads"          &&
3295       anArrayType != "quadstrips"     &&
3296       anArrayType != "polygons")
3297   {
3298     di << "Unexpected type of primitives array\n";
3299     return 1;
3300   }
3301
3302   TCollection_AsciiString aCommand;
3303   for (Standard_Integer anArgIndex = 3; anArgIndex < argc; anArgIndex++)
3304   {
3305     aCommand = argv[anArgIndex];
3306     aCommand.LowerCase();
3307     if (!aCommand.IsAscii())
3308     {
3309       di << "Unexpected argument: #" << aArgIndex - 1 << " , "
3310          << "should be an array element: 'v', 'b', 'e' \n";
3311       break;
3312     }
3313
3314     if (aCommand == "v")
3315     {
3316       hasVertex = Standard_True;
3317     }
3318
3319     anArgsArray->SetValue (anArgIndex - 2, aCommand);
3320   }
3321
3322   if (!hasVertex)
3323   {
3324     di << "You should pass any verticies in the list of array elements\n";
3325     return 1;
3326   }
3327
3328   Handle(Graphic3d_AspectMarker3d)    anAspPoints;
3329   if (anArrayType == "points")
3330   {
3331     anAspPoints = new Graphic3d_AspectMarker3d (Aspect_TOM_POINT, Quantity_NOC_YELLOW, 1.0f);
3332   }
3333
3334   // create primitives array object
3335   Handle(MyPArrayObject) aPObject = new MyPArrayObject (anArgsArray, anAspPoints);
3336
3337   // register the object in map
3338   VDisplayAISObject (aName, aPObject);
3339
3340   return 0;
3341 }
3342
3343 //=======================================================================
3344 //function : VSetLocation
3345 //purpose  : Change location of AIS interactive object
3346 //=======================================================================
3347
3348 static Standard_Integer VSetLocation (Draw_Interpretor& di,
3349                                       Standard_Integer argc,
3350                                       const char ** argv)
3351 {
3352   Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
3353   if (aContext.IsNull())
3354   {
3355     di << argv[0] << "ERROR : use 'vinit' command before " << "\n";
3356     return 1;
3357   }
3358
3359   if (argc != 5)
3360   {
3361     di << "ERROR : Usage : " << argv[0] << " name x y z; new location" << "\n";
3362     return 1;
3363   }
3364
3365   TCollection_AsciiString aName (argv[1]);
3366   Standard_Real aX = Draw::Atof (argv[2]);
3367   Standard_Real aY = Draw::Atof (argv[3]);
3368   Standard_Real aZ = Draw::Atof (argv[4]);
3369
3370   // find object
3371   ViewerTest_DoubleMapOfInteractiveAndName& aMap = GetMapOfAIS();
3372   Handle(AIS_InteractiveObject) anIObj;
3373   if (!aMap.IsBound2 (aName))
3374   {
3375     di << "Use 'vdisplay' before" << "\n";
3376     return 1;
3377   }
3378   else
3379   {
3380     anIObj = Handle(AIS_InteractiveObject)::DownCast (aMap.Find2 (aName));
3381
3382     // not an AIS_InteractiveObject
3383     if (anIObj.IsNull())
3384     {
3385       di << argv[1] << " : Not an AIS interactive object" << "\n";
3386       return 1;
3387     }
3388
3389     gp_Trsf aTrsf;
3390     aTrsf.SetTranslation (gp_Vec (aX, aY, aZ));
339