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