src/ViewerTest/ViewerTest_ObjectCommands.cxx

   1 // Created on: 1998-11-12
   2 // Created by: Robert COUBLANC
   3 // Copyright (c) 1998-1999 Matra Datavision
   4 // Copyright (c) 1999-2012 OPEN CASCADE SAS
   5 //
   6 // The content of this file is subject to the Open CASCADE Technology Public
   7 // License Version 6.5 (the "License"). You may not use the content of this file
   8 // except in compliance with the License. Please obtain a copy of the License
   9 // at http://www.opencascade.org and read it completely before using this file.
  10 //
  11 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
  12 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
  13 //
  14 // The Original Code and all software distributed under the License is
  15 // distributed on an "AS IS" basis, without warranty of any kind, and the
  16 // Initial Developer hereby disclaims all such warranties, including without
  17 // limitation, any warranties of merchantability, fitness for a particular
  18 // purpose or non-infringement. Please see the License for the specific terms
  19 // and conditions governing the rights and limitations under the License.
  20
  21
  22
  23 //===============================================
  24 //    AIS Objects Creation : Datums (axis,trihedrons,lines,planes)
  25 //===============================================
  26
  27 #ifdef HAVE_CONFIG_H
  28 #include <config.h>
  29 #endif
  30
  31 #include <ViewerTest.hxx>
  32
  33 #include <string.h>
  34
  35 #include <Quantity_NameOfColor.hxx>
  36 #include <Draw_Interpretor.hxx>
  37 #include <Draw.hxx>
  38 #include <Draw_Appli.hxx>
  39 #include <DBRep.hxx>
  40
  41 #include <OSD_Chronometer.hxx>
  42 #include <TCollection_AsciiString.hxx>
  43 #include <Visual3d_View.hxx>
  44 #include <V3d_Viewer.hxx>
  45 #include <V3d_View.hxx>
  46 #include <V3d_Plane.hxx>
  47 #include <V3d.hxx>
  48
  49 #include <AIS_Shape.hxx>
  50 #include <AIS_DisplayMode.hxx>
  51 #include <TColStd_MapOfInteger.hxx>
  52 #include <AIS_MapOfInteractive.hxx>
  53 #include <ViewerTest_DoubleMapOfInteractiveAndName.hxx>
  54 #include <ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName.hxx>
  55 #include <ViewerTest_EventManager.hxx>
  56
  57 #include <TopoDS_Solid.hxx>
  58 #include <BRepTools.hxx>
  59 #include <BRep_Builder.hxx>
  60 #include <TopAbs_ShapeEnum.hxx>
  61
  62 #include <TopoDS.hxx>
  63 #include <BRep_Tool.hxx>
  64 #include <TopExp_Explorer.hxx>
  65
  66 #include <BRepAdaptor_Curve.hxx>
  67 #include <BRepAdaptor_Surface.hxx>
  68
  69 #include <TopAbs.hxx>
  70 #include <TopExp.hxx>
  71 #include <TopoDS_Vertex.hxx>
  72 #include <TopoDS_Shape.hxx>
  73 #include <TopoDS_Face.hxx>
  74
  75 #include <Draw_Window.hxx>
  76 #include <AIS_ListIteratorOfListOfInteractive.hxx>
  77 #include <AIS_ListOfInteractive.hxx>
  78 #include <AIS_DisplayMode.hxx>
  79 #include <AIS_Shape.hxx>
  80
  81 #include <AIS_InteractiveContext.hxx>
  82 #include <Geom_Plane.hxx>
  83 #include <gp_Pln.hxx>
  84 #include <AIS_AngleDimension.hxx>
  85 #include <TCollection_ExtendedString.hxx>
  86 #include <GC_MakePlane.hxx>
  87 #include <gp_Circ.hxx>
  88 #include <AIS_Axis.hxx>
  89 #include <Geom_Axis2Placement.hxx>
  90 #include <Geom_Axis1Placement.hxx>
  91 #include <AIS_Trihedron.hxx>
  92 #include <AIS_Axis.hxx>
  93 #include <gp_Trsf.hxx>
  94 #include <TopLoc_Location.hxx>
  95
  96 #include <HLRAlgo_Projector.hxx>
  97 #include <HLRBRep_PolyAlgo.hxx>
  98 #include <HLRBRep_PolyHLRToShape.hxx>
  99 #include <Aspect_Window.hxx>
 100
 101 #include <Graphic3d_ArrayOfPoints.hxx>
 102 #include <Graphic3d_ArrayOfSegments.hxx>
 103 #include <Graphic3d_ArrayOfPolylines.hxx>
 104 #include <Graphic3d_ArrayOfTriangles.hxx>
 105 #include <Graphic3d_ArrayOfTriangleFans.hxx>
 106 #include <Graphic3d_ArrayOfTriangleStrips.hxx>
 107 #include <Graphic3d_ArrayOfQuadrangles.hxx>
 108 #include <Graphic3d_ArrayOfQuadrangleStrips.hxx>
 109 #include <Graphic3d_ArrayOfPolygons.hxx>
 110 #include <Graphic3d_Group.hxx>
 111 #include <Standard_Real.hxx>
 112
 113 #include <AIS_Circle.hxx>
 114 #include <AIS_Drawer.hxx>
 115 #include <BRepBuilderAPI_MakeEdge.hxx>
 116 #include <BRepBuilderAPI_MakeFace.hxx>
 117 #include <BRepBuilderAPI_MakeWire.hxx>
 118 #include <Geom_Circle.hxx>
 119 #include <GC_MakeCircle.hxx>
 120 #include <Prs3d_Presentation.hxx>
 121 #include <Select3D_SensitiveCircle.hxx>
 122 #include <SelectMgr_EntityOwner.hxx>
 123 #include <SelectMgr_Selection.hxx>
 124 #include <StdFail_NotDone.hxx>
 125 #include <StdPrs_ShadedShape.hxx>
 126 #include <TopoDS_Wire.hxx>
 127
 128 #include <AIS_ConnectedShape.hxx>
 129 #include <AIS_MultipleConnectedInteractive.hxx>
 130 #include <AIS_MultipleConnectedShape.hxx>
 131 #include <TopLoc_Location.hxx>
 132 #include <TColStd_ListOfInteger.hxx>
 133 #include <TColStd_ListIteratorOfListOfInteger.hxx>
 134
 135 #include <Select3D_SensitiveTriangle.hxx>
 136 #include <Select3D_SensitiveCurve.hxx>
 137 #include <BRepAdaptor_Curve.hxx>
 138 #include <StdPrs_Curve.hxx>
 139
 140 #include <BRepExtrema_ExtPC.hxx>
 141 #include <BRepExtrema_ExtPF.hxx>
 142
 143 #include <Prs3d_LineAspect.hxx>
 144
 145 #ifdef HAVE_STRINGS_H
 146 #include <strings.h>
 147 #endif
 148
 149 #ifdef WNT
 150 #define _CRT_SECURE_NO_DEPRECATE
 151 #pragma warning (disable:4996)
 152 #endif
 153
 154 extern ViewerTest_DoubleMapOfInteractiveAndName& GetMapOfAIS();
 155 extern Standard_Boolean VDisplayAISObject (const TCollection_AsciiString& theName,
 156                                            const Handle(AIS_InteractiveObject)& theAISObj,
 157                                            Standard_Boolean theReplaceIfExists = Standard_True);
 158 Standard_IMPORT int ViewerMainLoop(Standard_Integer argc, const char** argv);
 159 extern Handle(AIS_InteractiveContext)& TheAISContext();
 160
 161
 162 //==============================================================================
 163 //function : Vtrihedron 2d
 164 //purpose  : Create a plane with a 2D  trihedron from a faceselection
 165 //Draw arg : vtri2d  name
 166 //==============================================================================
 167 #include <AIS_PlaneTrihedron.hxx>
 168
 169
 170
 171 static int VTrihedron2D (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
 172
 173 {
 174   // Verification des arguments
 175   if ( argc!=2) {di<<argv[0]<<" error"<<"\n"; return 1;}
 176
 177   // Declarations
 178   Standard_Integer myCurrentIndex;
 179   // Fermeture des contextes
 180   TheAISContext()->CloseAllContexts();
 181   // Ouverture d'un contexte local et recuperation de son index.
 182   TheAISContext()->OpenLocalContext();
 183   myCurrentIndex=TheAISContext()->IndexOfCurrentLocal();
 184   // On active les modes de selections faces.
 185   TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(4) );
 186   di<<" Select a face ."<<"\n";
 187
 188   // Boucle d'attente waitpick.
 189   Standard_Integer argccc = 5;
 190   const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
 191   const char **argvvv = (const char **) bufff;
 192   while (ViewerMainLoop( argccc, argvvv) ) { }
 193   // fin de la boucle
 194
 195   TopoDS_Shape ShapeB;
 196   for(TheAISContext()->InitSelected() ;TheAISContext()->MoreSelected() ;TheAISContext()->NextSelected() ) {
 197     ShapeB = TheAISContext()->SelectedShape();
 198   }
 199
 200   TopoDS_Face  FaceB=TopoDS::Face(ShapeB);
 201
 202   // Construction du Plane
 203   // recuperation des edges des faces.
 204   TopExp_Explorer FaceExpB(FaceB,TopAbs_EDGE);
 205
 206   TopoDS_Edge EdgeB=TopoDS::Edge(FaceExpB.Current() );
 207   // declarations
 208   gp_Pnt A,B,C;
 209
 210   // si il y a plusieurs edges
 211   if (FaceExpB.More() ) {
 212     FaceExpB.Next();
 213     TopoDS_Edge EdgeC=TopoDS::Edge(FaceExpB.Current() );
 214     BRepAdaptor_Curve theCurveB(EdgeB);
 215     BRepAdaptor_Curve theCurveC(EdgeC);
 216     A=theCurveC.Value(0.1);
 217     B=theCurveC.Value(0.9);
 218     C=theCurveB.Value(0.5);
 219   }
 220   else {
 221     // FaceB a 1 unique edge courbe
 222     BRepAdaptor_Curve theCurveB(EdgeB);
 223     A=theCurveB.Value(0.1);
 224     B=theCurveB.Value(0.9);
 225     C=theCurveB.Value(0.5);
 226   }
 227   // Construction du Geom_Plane
 228   GC_MakePlane MkPlane(A,B,C);
 229   Handle(Geom_Plane) theGeomPlane=MkPlane.Value();
 230
 231   // Construction de l'AIS_PlaneTrihedron
 232   Handle(AIS_PlaneTrihedron) theAISPlaneTri= new AIS_PlaneTrihedron(theGeomPlane );
 233
 234   // Fermeture du contexte local.
 235   TheAISContext()->CloseLocalContext(myCurrentIndex);
 236
 237   // on le display & bind
 238   TheAISContext()->Display(theAISPlaneTri );
 239   GetMapOfAIS().Bind ( theAISPlaneTri ,argv[1]);
 240
 241   return 0;
 242 }
 243
 244
 245
 246 //==============================================================================
 247 //function : VTriherdron
 248 //purpose  : Create a trihedron. If no arguments are set, the default
 249 //           trihedron (Oxyz) is created.
 250 //Draw arg : vtrihedron  name  [Xo] [Yo] [Zo] [Zu] [Zv] [Zw] [Xu] [Xv] [Xw]
 251 //==============================================================================
 252
 253 static int VTrihedron (Draw_Interpretor& theDi,
 254                        Standard_Integer  theArgsNb,
 255                        const char**      theArgVec)
 256 {
 257   if (theArgsNb != 2 && theArgsNb != 5 && theArgsNb != 11)
 258   {
 259     theDi << theArgVec[0] << " Syntax error\n";
 260     return 1;
 261   }
 262
 263   gp_Pnt anOrigin (0.0, 0.0, 0.0);
 264   gp_Dir aDirZ = gp::DZ();
 265   gp_Dir aDirX = gp::DX();
 266   Standard_Integer anArgIter = 2; // 1st is an IO name
 267   if (anArgIter < theArgsNb)
 268   {
 269     anOrigin.SetX (atof (theArgVec[anArgIter++]));
 270     anOrigin.SetY (atof (theArgVec[anArgIter++]));
 271     anOrigin.SetZ (atof (theArgVec[anArgIter++]));
 272     if (anArgIter < theArgsNb)
 273     {
 274       Standard_Real aX = atof (theArgVec[anArgIter++]);
 275       Standard_Real aY = atof (theArgVec[anArgIter++]);
 276       Standard_Real aZ = atof (theArgVec[anArgIter++]);
 277       aDirZ.SetCoord (aX, aY, aZ);
 278
 279       aX = atof (theArgVec[anArgIter++]);
 280       aY = atof (theArgVec[anArgIter++]);
 281       aZ = atof (theArgVec[anArgIter++]);
 282       aDirX.SetCoord (aX, aY, aZ);
 283     }
 284   }
 285
 286   if (!aDirZ.IsNormal (aDirX, M_PI / 180.0))
 287   {
 288     theDi << theArgVec[0] << " - VectorX is not normal to VectorZ\n";
 289     return 1;
 290   }
 291
 292   Handle(Geom_Axis2Placement) aPlacement = new Geom_Axis2Placement (anOrigin, aDirZ, aDirX);
 293   Handle(AIS_Trihedron) aShape = new AIS_Trihedron (aPlacement);
 294   VDisplayAISObject (theArgVec[1], aShape);
 295   return 0;
 296 }
 297
 298 //==============================================================================
 299 //function : VSize
 300 //author   : ege
 301 //purpose  : Change the size of a named or selected trihedron
 302 //           if no name : it affects the trihedrons witch are selected otherwise nothing is donne
 303 //           if no value, the value is set at 100 by default
 304 //Draw arg : vsize [name] [size]
 305 //==============================================================================
 306
 307 static int VSize (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
 308
 309 {
 310   // Declaration de booleens
 311   Standard_Boolean             ThereIsName;
 312   Standard_Boolean             ThereIsCurrent;
 313   Standard_Real                value;
 314   Standard_Boolean             hascol;
 315 #ifdef DEB
 316   Quantity_NameOfColor         col;
 317 #else
 318   Quantity_NameOfColor         col = Quantity_NOC_BLACK ;
 319 #endif
 320
 321   // Verification des arguments
 322   if ( argc>3 ) {di<<argv[0]<<" Syntaxe error"<<"\n"; return 1;}
 323
 324   // Verification du nombre d'arguments
 325   if (argc==1)      {ThereIsName=Standard_False;value=100;}
 326   else if (argc==2) {ThereIsName=Standard_False;value=atof(argv[1]);}
 327   else              {ThereIsName=Standard_True;value=atof(argv[2]);}
 328
 329   // On ferme le contexte local pour travailler dans le contexte global
 330   if(TheAISContext()->HasOpenedContext())
 331     TheAISContext()->CloseLocalContext();
 332
 333   // On set le booleen ThereIsCurrent
 334   if (TheAISContext() -> NbCurrents() > 0) {ThereIsCurrent=Standard_True;}
 335   else {ThereIsCurrent=Standard_False;}
 336
 337
 338
 339   //===============================================================
 340   // Il n'y a pas de nom  mais des objets selectionnes
 341   //===============================================================
 342   if (!ThereIsName && ThereIsCurrent)
 343   {
 344
 345     ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName
 346       it (GetMapOfAIS());
 347
 348     while ( it.More() ) {
 349
 350       Handle(AIS_InteractiveObject) aShape=
 351         Handle(AIS_InteractiveObject)::DownCast(it.Key1());
 352
 353       if (!aShape.IsNull() &&  TheAISContext()->IsCurrent(aShape) )
 354       {
 355
 356         // On verifie que l'AIS InteraciveObject selectionne est bien
 357         // un AIS_Trihedron
 358         if (aShape->Type()==AIS_KOI_Datum && aShape->Signature()==3) {
 359
 360           if (aShape->HasColor()) {
 361             hascol=Standard_True;
 362
 363             // On recupere la couleur de aShape
 364             col=aShape->Color();}
 365
 366           else hascol=Standard_False;
 367
 368           // On downcast aShape  de AIS_InteractiveObject a AIS_Trihedron
 369           // pour lui appliquer la methode SetSize()
 370           Handle(AIS_Trihedron) aTrihedron = *(Handle(AIS_Trihedron)*) &aShape;
 371
 372           // C'est bien un triedre,on chage sa valeur!
 373           aTrihedron->SetSize(value);
 374
 375           // On donne la couleur au Trihedron
 376           if(hascol)   aTrihedron->SetColor(col);
 377           else         aTrihedron->UnsetColor();
 378
 379
 380           // The trihedron hasn't be errased from the map
 381           // so you just have to redisplay it
 382           TheAISContext() ->Redisplay(aTrihedron,Standard_False);
 383
 384         }
 385
 386       }
 387
 388       it.Next();
 389     }
 390
 391     TheAISContext() ->UpdateCurrentViewer();
 392   }
 393
 394   //===============================================================
 395   // Il n'y a pas d'arguments et aucuns objets selectionne Rien A Faire!
 396   //===============================================================
 397
 398
 399
 400   //===============================================================
 401   // Il y a un nom de triedre passe en argument
 402   //===============================================================
 403   if (ThereIsName) {
 404     TCollection_AsciiString name=argv[1];
 405
 406     // on verifie que ce nom correspond bien a une shape
 407     Standard_Boolean IsBound= GetMapOfAIS().IsBound2(name);
 408
 409     if (IsBound) {
 410
 411       // on recupere la shape dans la map des objets displayes
 412       Handle(AIS_InteractiveObject) aShape =
 413         Handle(AIS_InteractiveObject)::DownCast(GetMapOfAIS().Find2(name));
 414
 415       // On verifie que l'AIS InteraciveObject est bien
 416       // un AIS_Trihedron
 417       if (!aShape.IsNull() &&
 418         aShape->Type()==AIS_KOI_Datum && aShape->Signature()==3)
 419       {
 420
 421         if (aShape->HasColor()) {
 422           hascol=Standard_True;
 423
 424           // On recupere la couleur de aShape
 425           col=aShape->Color();}
 426
 427         else hascol=Standard_False;
 428
 429         // On downcast aShape de AIS_InteractiveObject a AIS_Trihedron
 430         // pour lui appliquer la methode SetSize()
 431         Handle(AIS_Trihedron) aTrihedron = *(Handle(AIS_Trihedron)*) &aShape;
 432
 433         // C'est bien un triedre,on chage sa valeur
 434         aTrihedron->SetSize(value);
 435
 436         // On donne la couleur au Trihedron
 437         if(hascol)   aTrihedron->SetColor(col);
 438         else         aTrihedron->UnsetColor();
 439
 440         // The trihedron hasn't be errased from the map
 441         // so you just have to redisplay it
 442         TheAISContext() ->Redisplay(aTrihedron,Standard_False);
 443
 444         TheAISContext() ->UpdateCurrentViewer();
 445       }
 446     }
 447   }
 448   return 0;
 449 }
 450
 451
 452 //==============================================================================
 453
 454 //==============================================================================
 455 //function : VPlaneTrihedron
 456 //purpose  : Create a plane from a trihedron selection. If no arguments are set, the default
 457 //Draw arg : vplanetri  name
 458 //==============================================================================
 459 #include <AIS_Plane.hxx>
 460
 461
 462
 463 static int VPlaneTrihedron (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
 464
 465 {
 466   // Verification des arguments
 467   if ( argc!=2) {di<<argv[0]<<" error"<<"\n"; return 1;}
 468
 469   // Declarations
 470   Standard_Integer myCurrentIndex;
 471   // Fermeture des contextes locaux
 472   TheAISContext()->CloseAllContexts();
 473
 474   // On recupere tous les trihedrons de la GetMapOfAIS()
 475   // et on active le mode de selection par face.
 476   // =================================================
 477
 478   // Ouverture d'un contexte local et recuperation de son index.
 479   TheAISContext()->OpenLocalContext(Standard_False);
 480   myCurrentIndex=TheAISContext()->IndexOfCurrentLocal();
 481
 482   ViewerTest_DoubleMapIteratorOfDoubleMapOfInteractiveAndName
 483     it (GetMapOfAIS());
 484   while(it.More()){
 485     Handle(AIS_InteractiveObject) ShapeA =
 486       Handle(AIS_InteractiveObject)::DownCast(it.Key1());
 487     // On verifie que c'est bien un trihedron
 488     if (!ShapeA.IsNull() &&
 489       ShapeA->Type()==AIS_KOI_Datum  && ShapeA->Signature()==3  ) {
 490         // on le downcast
 491         Handle(AIS_Trihedron) TrihedronA =((*(Handle(AIS_Trihedron)*)&ShapeA));
 492         // on le charge dans le contexte et on active le mode Plane.
 493         TheAISContext()->Load(TrihedronA,0,Standard_False);
 494         TheAISContext()->Activate(TrihedronA,3);
 495       }
 496       it.Next();
 497   }
 498
 499   di<<" Select a plane."<<"\n";
 500   // Boucle d'attente waitpick.
 501   Standard_Integer argccc = 5;
 502   const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
 503   const char **argvvv = (const char **) bufff;
 504   while (ViewerMainLoop( argccc, argvvv) ) { }
 505   // fin de la boucle
 506
 507   Handle(AIS_InteractiveObject) theIOB;
 508   for(TheAISContext()->InitSelected() ;TheAISContext()->MoreSelected() ;TheAISContext()->NextSelected() ) {
 509     theIOB = TheAISContext()->Interactive();
 510   }
 511   // on le downcast
 512   Handle(AIS_Plane) PlaneB =((*(Handle(AIS_Plane)*)&theIOB));
 513
 514   // Fermeture du contexte local.
 515   TheAISContext()->CloseLocalContext(myCurrentIndex);
 516
 517   // on le display & bind
 518   TheAISContext()->Display(PlaneB );
 519   GetMapOfAIS().Bind ( PlaneB ,argv[1]);
 520
 521   return 0;
 522 }
 523
 524
 525
 526 //==============================================================================
 527 // Fonction        First click      2de click
 528 //
 529 // vaxis           vertex           vertex
 530 //                 edge             None
 531 // vaxispara       edge             vertex
 532 // vaxisortho      edge             Vertex
 533 // vaxisinter      Face             Face
 534 //==============================================================================
 535
 536 //==============================================================================
 537 //function : VAxisBuilder
 538 //purpose  :
 539 //Draw arg : vaxis AxisName Xa Ya Za Xb Yb Zb
 540 //==============================================================================
 541 #include <TopoDS_Edge.hxx>
 542 #include <TopoDS_Vertex.hxx>
 543 #include <TopExp.hxx>
 544 #include <Geom_Line.hxx>
 545
 546 static int VAxisBuilder(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
 547 {
 548   // Declarations
 549   Standard_Boolean HasArg;
 550   TCollection_AsciiString name;
 551   Standard_Integer MyCurrentIndex;
 552
 553   // Verification
 554   if (argc<2 || argc>8 ) {di<<" Syntaxe error"<<"\n";return 1;}
 555   if (argc==8) HasArg=Standard_True;
 556   else HasArg=Standard_False;
 557
 558   name=argv[1];
 559   // Fermeture des contextes
 560   TheAISContext()->CloseAllContexts();
 561
 562   // Cas ou il y a des arguments
 563   // Purpose: Teste le constructeur AIS_Axis::AIS_Axis(x: Line from Geom)
 564   if (HasArg) {
 565     Standard_Real coord[6];
 566     for(Standard_Integer i=0;i<=5;i++){
 567       coord[i]=atof(argv[2+i]);
 568     }
 569     gp_Pnt p1(coord[0],coord[1],coord[2]), p2(coord[3],coord[4],coord[5]) ;
 570
 571     gp_Vec myVect (p1,p2);
 572     Handle(Geom_Line) myLine=new Geom_Line (p1 ,myVect );
 573     Handle(AIS_Axis) TheAxis=new AIS_Axis (myLine );
 574     GetMapOfAIS().Bind (TheAxis,name);
 575     TheAISContext()->Display(TheAxis);
 576   }
 577
 578   // Pas d'arguments
 579   else {
 580     // fonction vaxis
 581     // Purpose: Teste le constructeur AIS_Axis::AIS_Axis (x:Axis1Placement from Geom)
 582     if ( !strcasecmp(argv[0], "vaxis")) {
 583       TheAISContext()->OpenLocalContext();
 584       MyCurrentIndex=TheAISContext()->IndexOfCurrentLocal();
 585
 586       // Active le mode edge et le mode vertex
 587       TheAISContext()->ActivateStandardMode(AIS_Shape::SelectionType(1) );
 588       TheAISContext()->ActivateStandardMode(AIS_Shape::SelectionType(2) );
 589       di<<" Select an edge or a vertex."<<"\n";
 590
 591       // Boucle d'attente waitpick.
 592       Standard_Integer argcc = 5;
 593       const char *buff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
 594       const char **argvv = (const char **) buff;
 595       while (ViewerMainLoop( argcc, argvv) ) { }
 596       // fin de la boucle
 597
 598       // recuperation de la shape.
 599       TopoDS_Shape ShapeA;
 600       for(TheAISContext()->InitSelected() ;TheAISContext()->MoreSelected() ;TheAISContext()->NextSelected() ) {
 601         ShapeA = TheAISContext()->SelectedShape();
 602       }
 603       // recuperation de l'AIS_InteractiveObject
 604       //Handle(AIS_InteractiveObject) myAISio=TheAISContext()->Current();
 605       // down cast en AIS_Point si sig et type
 606       // AIS_Point -> Geom_Pnt ....
 607
 608       if (ShapeA.ShapeType()==TopAbs_VERTEX) {
 609         // on desactive le mode edge
 610         TheAISContext()->DeactivateStandardMode(AIS_Shape::SelectionType(2) );
 611         di<<" Select a different vertex."<<"\n";
 612
 613         TopoDS_Shape ShapeB;
 614         do {
 615           // Boucle d'attente waitpick.
 616           Standard_Integer argccc = 5;
 617           const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
 618           const char **argvvv = (const char **) bufff;
 619           while (ViewerMainLoop( argccc, argvvv) ) { }
 620           // fin de la boucle
 621           for(TheAISContext()->InitSelected() ;TheAISContext()->MoreSelected() ;TheAISContext()->NextSelected() ) {
 622             ShapeB = TheAISContext()->SelectedShape();
 623           }
 624
 625
 626         } while(ShapeB.IsSame(ShapeA) );
 627
 628         // Fermeture du context local
 629         TheAISContext()->CloseLocalContext(MyCurrentIndex);
 630
 631         // Construction de l'axe
 632         gp_Pnt   A=BRep_Tool::Pnt(TopoDS::Vertex(ShapeA)  );
 633         gp_Pnt   B=BRep_Tool::Pnt(TopoDS::Vertex(ShapeB)  );
 634         gp_Vec   V (A,B);
 635         gp_Dir   D (V);
 636         Handle(Geom_Axis1Placement) OrigineAndVect=new Geom_Axis1Placement (A,D);
 637         Handle(AIS_Axis) TheAxis=new AIS_Axis (OrigineAndVect);
 638         GetMapOfAIS().Bind (TheAxis,name);
 639         TheAISContext()->Display(TheAxis);
 640       }
 641       else {
 642         // Un unique edge (ShapeA) a ete picke
 643         // Fermeture du context local
 644         TheAISContext()->CloseLocalContext(MyCurrentIndex);
 645         // Constuction de l'axe
 646         TopoDS_Edge    ed =TopoDS::Edge(ShapeA);
 647         TopoDS_Vertex  Va,Vb;
 648         TopExp::Vertices(ed,Va,Vb );
 649         gp_Pnt A=BRep_Tool::Pnt(Va);
 650         gp_Pnt B=BRep_Tool::Pnt(Vb);
 651         gp_Vec  V (A,B);
 652         gp_Dir   D (V);
 653         Handle(Geom_Axis1Placement) OrigineAndVect=new Geom_Axis1Placement (A,D);
 654         Handle(AIS_Axis) TheAxis=new AIS_Axis (OrigineAndVect);
 655         GetMapOfAIS().Bind (TheAxis,name);
 656         TheAISContext()->Display(TheAxis);
 657       }
 658
 659     }
 660
 661     // Fonction axispara
 662     // Purpose: Teste le constructeur AIS_Axis::AIS_Axis(x: Axis2Placement from Geom, y: TypeOfAxis from AIS)
 663     else if ( !strcasecmp(argv[0], "vaxispara")) {
 664
 665       TheAISContext()->OpenLocalContext();
 666       MyCurrentIndex=TheAISContext()->IndexOfCurrentLocal();
 667
 668       // Active le mode edge
 669       TheAISContext()->ActivateStandardMode(AIS_Shape::SelectionType(2) );
 670       di<<" Select an edge."<<"\n";
 671
 672       // Boucle d'attente waitpick.
 673       Standard_Integer argcc = 5;
 674       const char *buff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
 675       const char **argvv = (const char **) buff;
 676       while (ViewerMainLoop( argcc, argvv) ) { }
 677       // fin de la boucle
 678
 679       TopoDS_Shape ShapeA;
 680       for(TheAISContext()->InitSelected() ;TheAISContext()->MoreSelected() ;TheAISContext()->NextSelected() ) {
 681         ShapeA = TheAISContext()->SelectedShape();
 682       }
 683       // Active le mode vertex et deactive edges
 684       TheAISContext()->DeactivateStandardMode(AIS_Shape::SelectionType(2) );
 685       TheAISContext()->ActivateStandardMode(AIS_Shape::SelectionType(1) );
 686       di<<" Select a vertex."<<"\n";
 687
 688       // Boucle d'attente waitpick.
 689       Standard_Integer argccc = 5;
 690       const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
 691       const char **argvvv = (const char **) bufff;
 692       while (ViewerMainLoop( argccc, argvvv) ) { }
 693       // fin de la boucle
 694
 695       // On peut choisir un pnt sur l'edge
 696       TopoDS_Shape ShapeB;
 697       for(TheAISContext()->InitSelected() ;TheAISContext()->MoreSelected() ;TheAISContext()->NextSelected() ) {
 698         ShapeB = TheAISContext()->SelectedShape();
 699       }
 700       // Fermeture du context local
 701       TheAISContext()->CloseLocalContext(MyCurrentIndex);
 702
 703       // Construction de l'axe
 704       TopoDS_Edge    ed=TopoDS::Edge(ShapeA) ;
 705       gp_Pnt B=BRep_Tool::Pnt(TopoDS::Vertex(ShapeB) );
 706       TopoDS_Vertex  Va,Vc;
 707       TopExp::Vertices(ed,Va,Vc );
 708       gp_Pnt A=BRep_Tool::Pnt(Va);
 709       gp_Pnt C=BRep_Tool::Pnt(Vc);
 710       gp_Vec  V (A,C);
 711       gp_Dir   D (V);
 712       Handle(Geom_Axis1Placement) OrigineAndVect=new Geom_Axis1Placement (B,D);
 713       Handle(AIS_Axis) TheAxis=new AIS_Axis (OrigineAndVect);
 714       GetMapOfAIS().Bind (TheAxis,name);
 715       TheAISContext()->Display(TheAxis);
 716
 717     }
 718
 719     // Fonction axisortho
 720     else  {
 721       TheAISContext()->OpenLocalContext();
 722       MyCurrentIndex=TheAISContext()->IndexOfCurrentLocal();
 723
 724       // Active le mode edge
 725       TheAISContext()->ActivateStandardMode(AIS_Shape::SelectionType(2) );
 726       di<<" Select an edge."<<"\n";
 727
 728       // Boucle d'attente waitpick.
 729       Standard_Integer argcc = 5;
 730       const char *buff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
 731       const char **argvv = (const char **) buff;
 732       while (ViewerMainLoop( argcc, argvv) ) { }
 733       // fin de la boucle
 734
 735       TopoDS_Shape ShapeA;
 736       for(TheAISContext()->InitSelected() ;TheAISContext()->MoreSelected() ;TheAISContext()->NextSelected() ) {
 737         ShapeA = TheAISContext()->SelectedShape();
 738       }
 739       // Active le mode vertex et deactive edges
 740       TheAISContext()->DeactivateStandardMode(AIS_Shape::SelectionType(2) );
 741       TheAISContext()->ActivateStandardMode(AIS_Shape::SelectionType(1) );
 742       di<<" Slect a vertex."<<"\n";
 743
 744       // Boucle d'attente waitpick.
 745       Standard_Integer argccc = 5;
 746       const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
 747       const char **argvvv = (const char **) bufff;
 748       while (ViewerMainLoop( argccc, argvvv) ) { }
 749       // fin de la boucle
 750
 751       // On peut choisir un pnt sur l'edge
 752       TopoDS_Shape ShapeB;
 753       for(TheAISContext()->InitSelected() ;TheAISContext()->MoreSelected() ;TheAISContext()->NextSelected() ) {
 754         ShapeB = TheAISContext()->SelectedShape();
 755       }
 756       // Fermeture du context local
 757       TheAISContext()->CloseLocalContext(MyCurrentIndex);
 758
 759       // Construction de l'axe
 760       TopoDS_Edge    ed=TopoDS::Edge(ShapeA) ;
 761       gp_Pnt B=BRep_Tool::Pnt(TopoDS::Vertex(ShapeB) );
 762       TopoDS_Vertex  Va,Vc;
 763       TopExp::Vertices(ed,Va,Vc );
 764       gp_Pnt A=BRep_Tool::Pnt(Va);
 765       gp_Pnt C=BRep_Tool::Pnt(Vc);
 766       gp_Pnt E(A.Y()+A.Z()-C.Y()-C.Z()  ,C.X()-A.X() ,C.X()-A.X() );
 767       gp_Vec  V (A,E);
 768       gp_Dir   D (V);
 769       Handle(Geom_Axis1Placement) OrigineAndVect=new Geom_Axis1Placement (B,D);
 770       Handle(AIS_Axis) TheAxis=new AIS_Axis (OrigineAndVect);
 771       GetMapOfAIS().Bind (TheAxis,name);
 772       TheAISContext()->Display(TheAxis);
 773
 774     }
 775
 776   }
 777   return 0;
 778 }
 779
 780
 781 //==============================================================================
 782 // Fonction        First click      Result
 783 //
 784 // vpoint          vertex           AIS_Point=Vertex
 785 //                 edge             AIS_Point=Middle of the edge
 786 //==============================================================================
 787
 788 //==============================================================================
 789 //function : VPointBuilder
 790 //purpose  : Build an AIS_Point from coordinates or with a selected vertex or edge
 791 //Draw arg : vpoint PoinName [Xa] [Ya] [Za]
 792 //==============================================================================
 793 #include <TopoDS_Edge.hxx>
 794 #include <TopoDS_Vertex.hxx>
 795 #include <TopExp.hxx>
 796 #include <AIS_Point.hxx>
 797 #include <Geom_CartesianPoint.hxx>
 798
 799 static int VPointBuilder(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
 800 {
 801   // Declarations
 802   Standard_Boolean HasArg;
 803   TCollection_AsciiString name;
 804   Standard_Integer myCurrentIndex;
 805
 806   // Verification
 807   if (argc<2 || argc>5 ) {di<<" Syntaxe error"<<"\n";return 1;}
 808   if (argc==5) HasArg=Standard_True;
 809   else HasArg=Standard_False;
 810
 811   name=argv[1];
 812   // Fermeture des contextes
 813   TheAISContext()->CloseAllContexts();
 814
 815   // Il y a des arguments: teste l'unique constructeur AIS_Pnt::AIS_Pnt(Point from Geom)
 816   if (HasArg) {
 817     Standard_Real thecoord[3];
 818     for(Standard_Integer i=0;i<=2;i++)
 819       thecoord[i]=atof(argv[2+i]);
 820     Handle(Geom_CartesianPoint )  myGeomPoint= new Geom_CartesianPoint (thecoord[0],thecoord[1],thecoord[2]);
 821     Handle(AIS_Point)  myAISPoint=new AIS_Point(myGeomPoint );
 822     GetMapOfAIS().Bind (myAISPoint,name);
 823     TheAISContext()->Display(myAISPoint);
 824   }
 825
 826   // Il n'a pas d'arguments
 827   else {
 828     TheAISContext()->OpenLocalContext();
 829     myCurrentIndex=TheAISContext()->IndexOfCurrentLocal();
 830
 831     // Active le mode Vertex et Edges
 832     TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(1) );
 833     TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(2) );
 834     di<<" Select a vertex or an edge(build the middle)"<<"\n";
 835
 836     // Boucle d'attente waitpick.
 837     Standard_Integer argcc = 5;
 838     const char *buff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
 839     const char **argvv = (const char **) buff;
 840     while (ViewerMainLoop( argcc, argvv) ) { }
 841     // fin de la boucle
 842
 843     TopoDS_Shape ShapeA;
 844     for (TheAISContext()->InitSelected() ;TheAISContext()->MoreSelected() ;TheAISContext()->NextSelected() ) {
 845       ShapeA= TheAISContext()->SelectedShape();
 846     }
 847
 848     if (ShapeA.ShapeType()==TopAbs_VERTEX ) {
 849       // Un vertex a ete selectionne
 850       // Fermeture du context local
 851       TheAISContext()->CloseLocalContext(myCurrentIndex);
 852
 853       // Construction du point
 854       gp_Pnt A=BRep_Tool::Pnt(TopoDS::Vertex(ShapeA ) );
 855       Handle(Geom_CartesianPoint) myGeomPoint= new Geom_CartesianPoint (A );
 856       Handle(AIS_Point)  myAISPoint = new AIS_Point  (myGeomPoint );
 857       GetMapOfAIS().Bind(myAISPoint,name);
 858       TheAISContext()->Display(myAISPoint);
 859     }
 860     else {
 861       // Un Edge a ete selectionne
 862       // Fermeture du context local
 863       TheAISContext()->CloseLocalContext(myCurrentIndex);
 864
 865       // Construction du point milieu de l'edge
 866       TopoDS_Edge myEdge=TopoDS::Edge(ShapeA);
 867       TopoDS_Vertex myVertexA,myVertexB;
 868       TopExp::Vertices (myEdge ,myVertexA ,myVertexB );
 869       gp_Pnt A=BRep_Tool::Pnt(myVertexA );
 870       gp_Pnt B=BRep_Tool::Pnt(myVertexB );
 871       // M est le milieu de [AB]
 872       Handle(Geom_CartesianPoint) myGeomPointM= new Geom_CartesianPoint ( (A.X()+B.X())/2  , (A.Y()+B.Y())/2  , (A.Z()+B.Z())/2  );
 873       Handle(AIS_Point)  myAISPointM = new AIS_Point  (myGeomPointM );
 874       GetMapOfAIS().Bind(myAISPointM,name);
 875       TheAISContext()->Display(myAISPointM);
 876     }
 877
 878   }
 879   return 0;
 880
 881 }
 882
 883 //==============================================================================
 884 // Function        1st click   2de click  3de click
 885 // vplane          Vertex      Vertex     Vertex
 886 //                 Vertex      Edge
 887 //                 Edge        Vertex
 888 //                 Face
 889 // vplanepara      Face        Vertex
 890 //                 Vertex      Face
 891 // vplaneortho     Face        Edge
 892 //                 Edge        Face
 893 //==============================================================================
 894
 895 //==============================================================================
 896 //function : VPlaneBuilder
 897 //purpose  : Build an AIS_Plane from selected entities or Named AIS components
 898 //Draw arg : vplane PlaneName [AxisName]  [PointName]
 899 //                            [PointName] [PointName] [PointName]
 900 //                            [PlaneName] [PointName]
 901 //==============================================================================
 902
 903 static Standard_Integer VPlaneBuilder (Draw_Interpretor& di,
 904                                        Standard_Integer argc,
 905                                        const char** argv)
 906 {
 907   // Declarations
 908   Standard_Boolean hasArg;
 909   TCollection_AsciiString aName;
 910   Standard_Integer aCurrentIndex;
 911
 912   // Verification
 913   if (argc<2 || argc>5 )
 914   {
 915     std::cout<<" Syntax error\n";
 916     return 1;
 917   }
 918   if (argc==5 || argc==4)
 919     hasArg=Standard_True;
 920   else
 921     hasArg=Standard_False;
 922
 923   aName=argv[1];
 924   // Close all contexts
 925   TheAISContext()->CloseAllContexts();
 926
 927   // There are some arguments
 928   if (hasArg)
 929   {
 930     if (!GetMapOfAIS().IsBound2(argv[2] ))
 931     {
 932       std::cout<<"vplane: error 1st name doesn't exist in the GetMapOfAIS()\n";
 933       return 1;
 934     }
 935     // Get shape from map
 936     Handle(AIS_InteractiveObject) aShapeA =
 937       Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2(argv[2] ));
 938
 939     // The first argument is an AIS_Point
 940     if (!aShapeA.IsNull() &&
 941         aShapeA->Type()==AIS_KOI_Datum &&
 942         aShapeA->Signature()==1)
 943     {
 944         // The second argument must also be an AIS_Point
 945         if (argc<5 || !GetMapOfAIS().IsBound2(argv[3]))
 946         {
 947           std::cout<<"vplane: error 2nd name doesn't exist in the GetMapOfAIS()\n";
 948           return 1;
 949         }
 950         // Get shape from map
 951         Handle(AIS_InteractiveObject) aShapeB =
 952           Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2(argv[3]));
 953         // If B is not an AIS_Point
 954         if (aShapeB.IsNull() ||
 955           (!(aShapeB->Type()==AIS_KOI_Datum && aShapeB->Signature()==1)))
 956         {
 957           std::cout<<"vplane: error 2nd object is expected to be an AIS_Point.\n";
 958           return 1;
 959         }
 960         // The third object is an AIS_Point
 961         if (!GetMapOfAIS().IsBound2(argv[4]) )
 962         {
 963           std::cout<<"vplane: error 3d name doesn't exist in the GetMapOfAIS().\n";
 964           return 1;
 965         }
 966         // Get shape from map
 967         Handle(AIS_InteractiveObject) aShapeC =
 968           Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2(argv[4]));
 969         // If C is not an AIS_Point
 970         if (aShapeC.IsNull() ||
 971           (!(aShapeC->Type()==AIS_KOI_Datum && aShapeC->Signature()==1)))
 972         {
 973           std::cout<<"vplane: error 3d object is expected to be an AIS_Point.\n";
 974           return 1;
 975         }
 976
 977         // Treatment of objects A, B, C
 978         // Downcast an AIS_IO to AIS_Point
 979         Handle(AIS_Point) anAISPointA = Handle(AIS_Point)::DownCast( aShapeA);
 980         Handle(AIS_Point) anAISPointB = Handle(AIS_Point)::DownCast( aShapeB);
 981         Handle(AIS_Point) anAISPointC = Handle(AIS_Point)::DownCast( aShapeC);
 982
 983         Handle(Geom_CartesianPoint ) aCartPointA =
 984           Handle(Geom_CartesianPoint)::DownCast( anAISPointA->Component());
 985
 986         Handle(Geom_CartesianPoint ) aCartPointB =
 987           Handle(Geom_CartesianPoint)::DownCast( anAISPointB->Component());
 988
 989         Handle(Geom_CartesianPoint ) aCartPointC =
 990           Handle(Geom_CartesianPoint)::DownCast( anAISPointC->Component());
 991
 992         // Verification that the three points are different
 993         if(abs(aCartPointB->X()-aCartPointA->X())<=Precision::Confusion() &&
 994            abs(aCartPointB->Y()-aCartPointA->Y())<=Precision::Confusion() &&
 995            abs(aCartPointB->Z()-aCartPointA->Z())<=Precision::Confusion())
 996         {
 997           // B=A
 998           std::cout<<"vplane error: same points"<<"\n";return 1;
 999         }
1000         if(abs(aCartPointC->X()-aCartPointA->X())<=Precision::Confusion() &&
1001            abs(aCartPointC->Y()-aCartPointA->Y())<=Precision::Confusion() &&
1002            abs(aCartPointC->Z()-aCartPointA->Z())<=Precision::Confusion())
1003         {
1004           // C=A
1005           std::cout<<"vplane error: same points"<<"\n";return 1;
1006         }
1007         if(abs(aCartPointC->X()-aCartPointB->X())<=Precision::Confusion() &&
1008            abs(aCartPointC->Y()-aCartPointB->Y())<=Precision::Confusion() &&
1009            abs(aCartPointC->Z()-aCartPointB->Z())<=Precision::Confusion())
1010         {
1011           // C=B
1012           std::cout<<"vplane error: same points"<<"\n";return 1;
1013         }
1014
1015         gp_Pnt A = aCartPointA->Pnt();
1016         gp_Pnt B = aCartPointB->Pnt();
1017         gp_Pnt C = aCartPointC->Pnt();
1018
1019         // Construction of AIS_Plane
1020         GC_MakePlane MkPlane (A,B,C);
1021         Handle(Geom_Plane) aGeomPlane = MkPlane.Value();
1022         Handle(AIS_Plane)  anAISPlane = new AIS_Plane(aGeomPlane );
1023         GetMapOfAIS().Bind (anAISPlane,aName );
1024         TheAISContext()->Display(anAISPlane);
1025       }
1026
1027       // The first argument is an AIS_Axis
1028       // Creation of a plane orthogonal to the axis through a point
1029     else if (aShapeA->Type()==AIS_KOI_Datum && aShapeA->Signature()==2 ) {
1030       // The second argument should be an AIS_Point
1031       if (argc!=4 || !GetMapOfAIS().IsBound2(argv[3] ) )
1032       {
1033         std::cout<<"vplane: error 2d name doesn't exist in the GetMapOfAIS()\n";
1034         return 1;
1035       }
1036       // Get shape from map
1037       Handle(AIS_InteractiveObject) aShapeB =
1038         Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2(argv[3]));
1039       // If B is not an AIS_Point
1040       if (aShapeB.IsNull() ||
1041         (!(aShapeB->Type()==AIS_KOI_Datum && aShapeB->Signature()==1)))
1042       {
1043         std::cout<<"vplane: error 2d object is expected to be an AIS_Point\n";
1044         return 1;
1045       }
1046
1047       // Treatment of objects A and B
1048       Handle(AIS_Axis) anAISAxisA = Handle(AIS_Axis)::DownCast(aShapeA);
1049       Handle(AIS_Point) anAISPointB = Handle(AIS_Point)::DownCast(aShapeB);
1050
1051       Handle(Geom_Line ) aGeomLineA = anAISAxisA ->Component();
1052       Handle(Geom_Point) aGeomPointB = anAISPointB->Component()  ;
1053
1054       gp_Ax1 anAxis = aGeomLineA->Position();
1055       Handle(Geom_CartesianPoint) aCartPointB =
1056         Handle(Geom_CartesianPoint)::DownCast(aGeomPointB);
1057
1058       gp_Dir D =anAxis.Direction();
1059       gp_Pnt B = aCartPointB->Pnt();
1060
1061       // Construction of AIS_Plane
1062       Handle(Geom_Plane) aGeomPlane = new Geom_Plane(B,D);
1063       Handle(AIS_Plane) anAISPlane = new AIS_Plane(aGeomPlane,B );
1064       GetMapOfAIS().Bind (anAISPlane,aName );
1065       TheAISContext()->Display(anAISPlane);
1066
1067     }
1068     // The first argumnet is an AIS_Plane
1069     // Creation of a plane parallel to the plane passing through the point
1070     else if (aShapeA->Type()==AIS_KOI_Datum && aShapeA->Signature()==7)
1071     {
1072       // The second argument should be an AIS_Point
1073       if (argc!=4 || !GetMapOfAIS().IsBound2(argv[3]))
1074       {
1075         std::cout<<"vplane: error 2d name doesn't exist in the GetMapOfAIS()\n";
1076         return 1;
1077       }
1078       // Get shape from map
1079       Handle(AIS_InteractiveObject) aShapeB =
1080         Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2(argv[3]));
1081       // B should be an AIS_Point
1082       if (aShapeB.IsNull() ||
1083          (!(aShapeB->Type()==AIS_KOI_Datum && aShapeB->Signature()==1)))
1084       {
1085         std::cout<<"vplane: error 2d object is expected to be an AIS_Point\n";
1086         return 1;
1087       }
1088
1089       // Treatment of objects A and B
1090       Handle(AIS_Plane) anAISPlaneA = Handle(AIS_Plane)::DownCast(aShapeA);
1091       Handle(AIS_Point) anAISPointB = Handle(AIS_Point)::DownCast(aShapeB);
1092
1093       Handle(Geom_Plane) aNewGeomPlane= anAISPlaneA->Component();
1094       Handle(Geom_Point) aGeomPointB = anAISPointB->Component();
1095
1096       Handle(Geom_CartesianPoint) aCartPointB =
1097         Handle(Geom_CartesianPoint)::DownCast(aGeomPointB);
1098       gp_Pnt B= aCartPointB->Pnt();
1099
1100       // Construction of an AIS_Plane
1101       Handle(AIS_Plane) anAISPlane = new AIS_Plane(aNewGeomPlane, B);
1102       GetMapOfAIS().Bind (anAISPlane, aName);
1103       TheAISContext()->Display(anAISPlane);
1104     }
1105     // Error
1106     else
1107     {
1108       std::cout<<"vplane: error 1st object is not an AIS\n";
1109       return 1;
1110     }
1111   }
1112   // There are no arguments
1113   else
1114   {
1115     // Function vplane
1116     // Test the constructor AIS_Plane::AIS_Plane(Geom_Plane, Standard_Boolean )
1117     if (!strcasecmp(argv[0], "vplane"))
1118     {
1119       TheAISContext()->OpenLocalContext();
1120       aCurrentIndex=TheAISContext()->IndexOfCurrentLocal();
1121
1122       // Active modes Vertex, Edge and Face
1123       TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(1));
1124       TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(2));
1125       TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(4));
1126       std::cout<<"Select a vertex, a face or an edge\n";
1127
1128       // Wait for picking
1129       Standard_Integer argcc = 5;
1130       const char *buff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
1131       const char **argvv = (const char **) buff;
1132       while (ViewerMainLoop( argcc, argvv) ) { }
1133       // end of the loop
1134
1135       TopoDS_Shape aShapeA;
1136       for (TheAISContext()->InitSelected();
1137            TheAISContext()->MoreSelected();
1138            TheAISContext()->NextSelected())
1139       {
1140         aShapeA = TheAISContext()->SelectedShape();
1141       }
1142
1143       // aShapeA is a Vertex
1144       if (aShapeA.ShapeType()==TopAbs_VERTEX )
1145       {
1146         TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(4));
1147         std::cout<<" Select an edge or a different vertex\n";
1148
1149         // Wait for picking
1150         Standard_Integer argccc = 5;
1151         const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
1152         const char **argvvv = (const char **) bufff;
1153         while (ViewerMainLoop( argccc, argvvv) ) { }
1154         // end of the loop
1155
1156         TopoDS_Shape aShapeB;
1157         for (TheAISContext()->InitSelected();
1158           TheAISContext()->MoreSelected();
1159           TheAISContext()->NextSelected())
1160         {
1161           aShapeB = TheAISContext()->SelectedShape();
1162         }
1163         // aShapeB is a Vertex
1164         if (aShapeB.ShapeType()==TopAbs_VERTEX)
1165         {
1166           // A and B are the same
1167           if (aShapeB.IsSame(aShapeA))
1168           {
1169             std::cout<<" vplane: error, same points selected\n";
1170             return 1;
1171           }
1172           TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(2));
1173           std::cout<<" Select a different vertex\n";
1174
1175           // Wait for picking
1176           Standard_Integer argcccc = 5;
1177           const char *buffff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
1178           const char **argvvvv = (const char **) buffff;
1179           while (ViewerMainLoop( argcccc, argvvvv) ) { }
1180           // end of the loop
1181
1182           TopoDS_Shape aShapeC;
1183           for (TheAISContext()->InitSelected();
1184                TheAISContext()->MoreSelected();
1185                TheAISContext()->NextSelected())
1186           {
1187             aShapeC = TheAISContext()->SelectedShape();
1188           }
1189           // aShapeC is the same as A or B
1190           if (aShapeC.IsSame(aShapeA)||aShapeC.IsSame(aShapeB))
1191           {
1192             std::cout<<" vplane: error, same points selected\n";
1193             return 1;
1194           }
1195
1196           // Close the local context
1197           TheAISContext()->CloseLocalContext(aCurrentIndex);
1198
1199           // Construction of plane
1200           gp_Pnt A = BRep_Tool::Pnt(TopoDS::Vertex(aShapeA));
1201           gp_Pnt B = BRep_Tool::Pnt(TopoDS::Vertex(aShapeB));
1202           gp_Pnt C = BRep_Tool::Pnt(TopoDS::Vertex(aShapeC));
1203           GC_MakePlane MkPlane(A, B, C);
1204           Handle(Geom_Plane) aGeomPlane = MkPlane.Value();
1205           Handle(AIS_Plane) anAISPlane = new AIS_Plane (aGeomPlane);
1206           GetMapOfAIS().Bind (anAISPlane, aName);
1207           TheAISContext()->Display(anAISPlane);
1208         }
1209         // ShapeB is an edge
1210         else
1211         {
1212           // Verify that the vertex is not on the edge ShapeB
1213           TopoDS_Edge anEdgeB = TopoDS::Edge(aShapeB);
1214           TopoDS_Vertex aVertA = TopoDS::Vertex(aShapeA);
1215
1216           BRepExtrema_ExtPC OrthoProj(aVertA, anEdgeB);
1217           if (OrthoProj.SquareDistance(1)<Precision::Approximation())
1218           {
1219             // The vertex is on the edge
1220             std::cout<<" vplane: error point is on the edge\n";
1221             return 1;
1222           }
1223           else
1224           {
1225             // Close the local context
1226             TheAISContext()->CloseLocalContext(aCurrentIndex);
1227             // Construction of plane
1228             gp_Pnt A = BRep_Tool::Pnt(aVertA);
1229             TopoDS_Vertex aVBa, aVBb;
1230             TopExp::Vertices(anEdgeB ,aVBa ,aVBb);
1231             gp_Pnt aBa = BRep_Tool::Pnt(aVBa);
1232             gp_Pnt aBb = BRep_Tool::Pnt(aVBb);
1233             GC_MakePlane MkPlane (A, aBa, aBb);
1234             Handle(Geom_Plane) aGeomPlane = MkPlane.Value();
1235             Handle(AIS_Plane) anAISPlane = new AIS_Plane (aGeomPlane);
1236             GetMapOfAIS().Bind (anAISPlane, aName);
1237             TheAISContext()->Display(anAISPlane);
1238           }
1239         }
1240       }
1241       // aShapeA is an edge
1242       else if (aShapeA.ShapeType()==TopAbs_EDGE)
1243       {
1244         TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(4));
1245         TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(2));
1246         std::cout<<" Select a vertex that don't belong to the edge\n";
1247
1248         // Wait for picking
1249         Standard_Integer argccc = 5;
1250         const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
1251         const char **argvvv = (const char **) bufff;
1252         while (ViewerMainLoop( argccc, argvvv) ) { }
1253         // end of the loop
1254
1255         TopoDS_Shape aShapeB;
1256         for (TheAISContext()->InitSelected();
1257              TheAISContext()->MoreSelected();
1258              TheAISContext()->NextSelected())
1259         {
1260           aShapeB = TheAISContext()->SelectedShape();
1261         }
1262         // aShapeB should be a Vertex
1263         // Check that the vertex aShapeB is not on the edge
1264         TopoDS_Edge anEdgeA = TopoDS::Edge(aShapeA);
1265         TopoDS_Vertex aVertB = TopoDS::Vertex(aShapeB);
1266
1267         BRepExtrema_ExtPC OrthoProj (aVertB, anEdgeA);
1268         if (OrthoProj.SquareDistance(1)<Precision::Approximation())
1269         {
1270           // The vertex is on the edge
1271           std::cout<<" vplane: error point is on the edge\n";
1272           return 1;
1273         }
1274         else
1275         {
1276           // Close the local context
1277           TheAISContext()->CloseLocalContext(aCurrentIndex);
1278           // Construction of plane
1279           gp_Pnt B = BRep_Tool::Pnt(aVertB);
1280           TopoDS_Vertex aVAa, aVAb;
1281           TopExp::Vertices(anEdgeA, aVAa, aVAb);
1282           gp_Pnt Aa = BRep_Tool::Pnt(aVAa);
1283           gp_Pnt Ab = BRep_Tool::Pnt(aVAb);
1284           GC_MakePlane MkPlane (B,Aa,Ab);
1285           Handle(Geom_Plane) aGeomPlane = MkPlane.Value();
1286           Handle(AIS_Plane) anAISPlane = new AIS_Plane (aGeomPlane);
1287           GetMapOfAIS().Bind (anAISPlane ,aName);
1288           TheAISContext()->Display(anAISPlane);
1289         }
1290       }
1291       // aShapeA is a Face
1292       else
1293       {
1294         // Close the local context: nothing to select
1295         TheAISContext()->CloseLocalContext(aCurrentIndex);
1296         // Construction of plane
1297         TopoDS_Face aFace = TopoDS::Face(aShapeA);
1298         BRepAdaptor_Surface aSurface (aFace, Standard_False);
1299         if (aSurface.GetType()==GeomAbs_Plane)
1300         {
1301           gp_Pln aPlane = aSurface.Plane();
1302           Handle(Geom_Plane) aGeomPlane = new Geom_Plane(aPlane);
1303           Handle(AIS_Plane) anAISPlane = new AIS_Plane(aGeomPlane);
1304           GetMapOfAIS().Bind (anAISPlane, aName);
1305           TheAISContext()->Display(anAISPlane);
1306         }
1307         else
1308         {
1309           std::cout<<" vplane: error\n";
1310           return 1;
1311         }
1312       }
1313     }
1314
1315     // Function vPlanePara
1316     // ===================
1317     // test the constructor AIS_Plane::AIS_Plane(Geom_Plane,gp_Pnt)
1318     else if (!strcasecmp(argv[0], "vplanepara"))
1319     {
1320       TheAISContext()->OpenLocalContext();
1321       aCurrentIndex = TheAISContext()->IndexOfCurrentLocal();
1322
1323       // Activate modes Vertex and Face
1324       TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(1));
1325       TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(4));
1326       std::cout<<" Select a vertex or a face\n";
1327
1328       // Wait for picking
1329       Standard_Integer argcc = 5;
1330       const char *buff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
1331       const char **argvv = (const char **) buff;
1332       while (ViewerMainLoop( argcc, argvv) ) { }
1333       // end of the loop
1334
1335       TopoDS_Shape aShapeA;
1336       for (TheAISContext()->InitSelected();
1337            TheAISContext()->MoreSelected();
1338            TheAISContext()->NextSelected())
1339       {
1340         aShapeA = TheAISContext()->SelectedShape();
1341       }
1342
1343       if (aShapeA.ShapeType()==TopAbs_VERTEX )
1344       {
1345         // aShapeA is a vertex
1346         // Deactivate the mode Vertex
1347         TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(1));
1348         std::cout<<" Select a face\n";
1349
1350         // Wait for picking
1351         Standard_Integer argccc = 5;
1352         const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
1353         const char **argvvv = (const char **) bufff;
1354         while (ViewerMainLoop( argccc, argvvv) ) { }
1355         // end of the loop
1356
1357         TopoDS_Shape aShapeB;
1358         for (TheAISContext()->InitSelected();
1359              TheAISContext()->MoreSelected();
1360              TheAISContext()->NextSelected())
1361         {
1362           // A vertex ShapeA can be on Face ShapeB
1363           aShapeB = TheAISContext()->SelectedShape();
1364         }
1365
1366         // Close the local context
1367         TheAISContext()->CloseLocalContext(aCurrentIndex);
1368
1369         // Construction of plane
1370         gp_Pnt A = BRep_Tool::Pnt(TopoDS::Vertex(aShapeA));
1371
1372         TopoDS_Face aFace = TopoDS::Face(aShapeB);
1373         BRepAdaptor_Surface aSurface (aFace, Standard_False);
1374         if (aSurface.GetType()==GeomAbs_Plane )
1375         {
1376           gp_Pln aPlane = aSurface.Plane();
1377           // Construct a plane parallel to aGeomPlane through A
1378           aPlane.SetLocation(A);
1379           Handle(Geom_Plane) aGeomPlane = new Geom_Plane (aPlane);
1380           Handle(AIS_Plane) aAISPlane = new AIS_Plane (aGeomPlane, A);
1381           GetMapOfAIS().Bind (aAISPlane ,aName);
1382           TheAISContext()->Display(aAISPlane);
1383         }
1384         else
1385         {
1386           std::cout<<" vplanepara: error\n";
1387           return 1;
1388         }
1389       }
1390       else
1391       {
1392         // ShapeA is a Face
1393         // Deactive the mode Face
1394         TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(4));
1395         std::cout<<" Select a vertex\n";
1396
1397         // Wait for picking
1398         Standard_Integer argccc = 5;
1399         const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
1400         const char **argvvv = (const char **) bufff;
1401         while (ViewerMainLoop( argccc, argvvv) ) { }
1402         // end of the loop
1403
1404         TopoDS_Shape aShapeB;
1405         for (TheAISContext()->InitSelected();
1406              TheAISContext()->MoreSelected();
1407              TheAISContext()->NextSelected())
1408         {
1409           // A vertex ShapeB can be on Face ShapeA
1410           aShapeB = TheAISContext()->SelectedShape();
1411         }
1412         // Close the local context
1413         TheAISContext()->CloseLocalContext(aCurrentIndex);
1414
1415         // Construction of plane
1416         gp_Pnt B = BRep_Tool::Pnt(TopoDS::Vertex(aShapeB));
1417
1418         TopoDS_Face aFace=TopoDS::Face(aShapeA);
1419         BRepAdaptor_Surface aSurface (aFace, Standard_False);
1420         if (aSurface.GetType()==GeomAbs_Plane )
1421         {
1422           gp_Pln aPlane = aSurface.Plane();
1423           aPlane.SetLocation(B);
1424           Handle(Geom_Plane) aGeomPlane = new Geom_Plane (aPlane);
1425           // Construct a plane parallel to aGeomPlane through B
1426           Handle(AIS_Plane) anAISPlane = new AIS_Plane (aGeomPlane, B);
1427           GetMapOfAIS().Bind (anAISPlane, aName);
1428           TheAISContext()->Display(anAISPlane);
1429         }
1430         else
1431         {
1432           std::cout<<" vplanepara: error"<<"\n";return 1;
1433         }
1434       }
1435     }
1436
1437     // Function vplaneortho
1438     // ====================
1439     // test the constructor AIS_Plane::AIS_Plane(Geom_Plane,gp_Pnt,gp_Pnt,gp_Pnt)
1440     else
1441     {
1442       TheAISContext()->OpenLocalContext();
1443       aCurrentIndex = TheAISContext()->IndexOfCurrentLocal();
1444
1445       // Activate the modes Edge and Face
1446       TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(2));
1447       TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(4));
1448       std::cout<<" Select a face and an edge coplanar\n";
1449
1450       // Wait for picking
1451       Standard_Integer argcc = 5;
1452       const char *buff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
1453       const char **argvv = (const char **) buff;
1454       while (ViewerMainLoop( argcc, argvv) ) { }
1455       // end of the loop
1456
1457       TopoDS_Shape aShapeA;
1458       for (TheAISContext()->InitSelected();
1459            TheAISContext()->MoreSelected();
1460            TheAISContext()->NextSelected())
1461       {
1462         aShapeA = TheAISContext()->SelectedShape();
1463       }
1464
1465       if (aShapeA.ShapeType()==TopAbs_EDGE )
1466       {
1467         // ShapeA is an edge, deactivate the mode Edge...
1468         TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(2));
1469         std::cout<<" Select a face\n";
1470
1471         // Wait for picking
1472         Standard_Integer argccc = 5;
1473         const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
1474         const char **argvvv = (const char **) bufff;
1475         while (ViewerMainLoop( argccc, argvvv) ) { }
1476         // end of the loop
1477
1478         TopoDS_Shape aShapeB;
1479         for (TheAISContext()->InitSelected();
1480              TheAISContext()->MoreSelected();
1481              TheAISContext()->NextSelected())
1482         {
1483           // Edge ShapeA can be on Face ShapeB
1484           aShapeB = TheAISContext()->SelectedShape();
1485         }
1486
1487         // Close the local context
1488         TheAISContext()->CloseLocalContext(aCurrentIndex);
1489
1490         // Construction of plane
1491         TopoDS_Edge anEdgeA = TopoDS::Edge(aShapeA);
1492         TopoDS_Vertex aVAa, aVAb;
1493         TopExp::Vertices(anEdgeA, aVAa, aVAb);
1494         gp_Pnt Aa = BRep_Tool::Pnt(aVAa);
1495         gp_Pnt Ab = BRep_Tool::Pnt(aVAb);
1496         gp_Vec ab (Aa,Ab);
1497
1498         gp_Dir Dab (ab);
1499         // Creation of rotation axis
1500         gp_Ax1 aRotAxis (Aa,Dab);
1501
1502         TopoDS_Face aFace = TopoDS::Face(aShapeB);
1503         // The edge must be parallel to the face
1504         BRepExtrema_ExtPF aHeightA (aVAa, aFace);
1505         BRepExtrema_ExtPF aHeightB (aVAb, aFace);
1506         // Compare to heights
1507         if (fabs(sqrt(aHeightA.SquareDistance(1)) - sqrt(aHeightB.SquareDistance(1)))
1508             >Precision::Confusion())
1509         {
1510           // the edge is not parallel to the face
1511           std::cout<<" vplaneortho error: the edge is not parallel to the face\n";
1512           return 1;
1513         }
1514         // the edge is OK
1515         BRepAdaptor_Surface aSurface (aFace, Standard_False);
1516         if (aSurface.GetType()==GeomAbs_Plane)
1517         {
1518           gp_Pln aPlane = aSurface.Plane();
1519           // It rotates a half turn round the axis of rotation
1520           aPlane.Rotate(aRotAxis , M_PI/2);
1521
1522           Handle(Geom_Plane) aGeomPlane = new Geom_Plane (aPlane);
1523           // constructed aGeomPlane parallel to a plane containing the edge (center mid-edge)
1524           gp_Pnt aMiddle ((Aa.X()+Ab.X() )/2 ,(Aa.Y()+Ab.Y() )/2 ,(Aa.Z()+Ab.Z() )/2 );
1525           Handle(AIS_Plane) anAISPlane = new AIS_Plane (aGeomPlane, aMiddle);
1526           GetMapOfAIS().Bind (anAISPlane, aName);
1527           TheAISContext()->Display(anAISPlane);
1528         }
1529         else
1530         {
1531           std::cout<<" vplaneortho: error\n";
1532           return 1;
1533         }
1534       }
1535       else
1536       {
1537         // ShapeA is a Face, deactive the mode Face.
1538         TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(4));
1539         std::cout<<" Select an edge\n";
1540
1541         // Wait for picking
1542         Standard_Integer argccc = 5;
1543         const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
1544         const char **argvvv = (const char **) bufff;
1545         while (ViewerMainLoop( argccc, argvvv) ) { }
1546         // end of the loop
1547
1548         TopoDS_Shape aShapeB;
1549         for (TheAISContext()->InitSelected();
1550              TheAISContext()->MoreSelected();
1551              TheAISContext()->NextSelected())
1552         {
1553           // Edge ShapeB can be on Face ShapeA
1554           aShapeB = TheAISContext()->SelectedShape();
1555         }
1556         // Close the local context
1557         TheAISContext()->CloseLocalContext(aCurrentIndex);
1558
1559         // Construction of plane
1560         TopoDS_Edge anEdgeB = TopoDS::Edge(aShapeB);
1561         TopoDS_Vertex aVBa, aVBb;
1562         TopExp::Vertices(anEdgeB, aVBa, aVBb);
1563         gp_Pnt aBa = BRep_Tool::Pnt(aVBa);
1564         gp_Pnt aBb = BRep_Tool::Pnt(aVBb);
1565         gp_Vec ab (aBa,aBb);
1566         gp_Dir Dab (ab);
1567         // Creation of rotation axe
1568         gp_Ax1 aRotAxis (aBa,Dab);
1569
1570         TopoDS_Face aFace = TopoDS::Face(aShapeA);
1571         // The edge must be parallel to the face
1572         BRepExtrema_ExtPF aHeightA (aVBa, aFace);
1573         BRepExtrema_ExtPF aHeightB (aVBb, aFace);
1574         // Comparing the two heights
1575         if (fabs(sqrt(aHeightA.SquareDistance(1)) - sqrt(aHeightB.SquareDistance(1)))
1576             >Precision::Confusion())
1577         {
1578           // the edge is not parallel to the face
1579           std::cout<<" vplaneortho error: the edge is not parallel to the face\n";
1580           return 1;
1581         }
1582         // The edge is OK
1583         BRepAdaptor_Surface aSurface (aFace, Standard_False);
1584         if (aSurface.GetType()==GeomAbs_Plane)
1585         {
1586           gp_Pln aPlane = aSurface.Plane();
1587           // It rotates a half turn round the axis of rotation
1588           aPlane.Rotate(aRotAxis , M_PI/2);
1589           Handle(Geom_Plane) aGeomPlane = new Geom_Plane (aPlane);
1590           // constructed aGeomPlane parallel to a plane containing the edge theGeomPlane (center mid-edge)
1591           gp_Pnt aMiddle ((aBa.X()+aBb.X() )/2 , (aBa.Y()+aBb.Y() )/2 , (aBa.Z()+aBb.Z() )/2 );
1592           Handle(AIS_Plane) anAISPlane = new AIS_Plane (aGeomPlane, aMiddle);
1593           GetMapOfAIS().Bind (anAISPlane ,aName);
1594           TheAISContext()->Display(anAISPlane);
1595         }
1596         else
1597         {
1598           std::cout<<" vplaneortho: error\n";
1599           return 1;
1600         }
1601       }
1602     }
1603   }
1604   return 0;
1605 }
1606
1607
1608 //==============================================================================
1609 // Fonction  vline
1610 // ---------------  Uniquement par parametre. Pas de selection dans le viewer.
1611 //==============================================================================
1612
1613 //==============================================================================
1614 //function : VLineBuilder
1615 //purpose  : Build an AIS_Line
1616 //Draw arg : vline LineName  [AIS_PointName] [AIS_PointName]
1617 //                           [Xa] [Ya] [Za]   [Xb] [Yb] [Zb]
1618 //==============================================================================
1619 #include <Geom_CartesianPoint.hxx>
1620 #include <AIS_Line.hxx>
1621
1622
1623 static int VLineBuilder(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
1624 {
1625   Standard_Integer myCurrentIndex;
1626   // Verifications
1627   if (argc!=4 && argc!=8 && argc!=2 )  {di<<"vline error: number of arguments not correct "<<"\n";return 1; }
1628   // Fermeture des contextes
1629   TheAISContext()->CloseAllContexts();
1630
1631   // On recupere les parametres
1632   Handle(AIS_InteractiveObject) theShapeA;
1633   Handle(AIS_InteractiveObject) theShapeB;
1634
1635   // Parametres: AIS_Point AIS_Point
1636   // ===============================
1637   if (argc==4) {
1638     theShapeA=
1639       Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2(argv[2]));
1640     // On verifie que c'est bien une AIS_Point
1641     if (!theShapeA.IsNull() &&
1642       theShapeA->Type()==AIS_KOI_Datum && theShapeA->Signature()==1) {
1643         // on recupere le deuxieme AIS_Point
1644         theShapeB=
1645           Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2(argv[3]));
1646         if (theShapeA.IsNull() ||
1647           (!(theShapeB->Type()==AIS_KOI_Datum && theShapeB->Signature()==1)))
1648         {
1649           di <<"vline error: wrong type of 2de argument."<<"\n";
1650           return 1;
1651         }
1652       }
1653     else {di <<"vline error: wrong type of 1st argument."<<"\n";return 1; }
1654     // Les deux parametres sont du bon type. On verifie que les points ne sont pas confondus
1655     Handle(AIS_Point) theAISPointA= *(Handle(AIS_Point)*)& theShapeA;
1656     Handle(AIS_Point) theAISPointB= *(Handle(AIS_Point)*)& theShapeB;
1657
1658     Handle(Geom_Point ) myGeomPointBA=  theAISPointA->Component();
1659     Handle(Geom_CartesianPoint ) myCartPointA= *((Handle(Geom_CartesianPoint)*)&  myGeomPointBA);
1660     //    Handle(Geom_CartesianPoint ) myCartPointA= *(Handle(Geom_CartesianPoint)*)& (theAISPointA->Component() ) ;
1661
1662     Handle(Geom_Point ) myGeomPointB=  theAISPointB->Component();
1663     Handle(Geom_CartesianPoint ) myCartPointB= *((Handle(Geom_CartesianPoint)*)&  myGeomPointB);
1664     //    Handle(Geom_CartesianPoint ) myCartPointB= *(Handle(Geom_CartesianPoint)*)& (theAISPointB->Component() ) ;
1665
1666     if (myCartPointB->X()==myCartPointA->X() && myCartPointB->Y()==myCartPointA->Y() && myCartPointB->Z()==myCartPointA->Z() ) {
1667       // B=A
1668       di<<"vline error: same points"<<"\n";return 1;
1669     }
1670     // Les deux points sont OK...Construction de l'AIS_Line (en faite, le segment AB)
1671     Handle(AIS_Line) theAISLine= new AIS_Line(myCartPointA,myCartPointB );
1672     GetMapOfAIS().Bind(theAISLine,argv[1] );
1673     TheAISContext()->Display(theAISLine );
1674
1675   }
1676
1677   // Parametres 6 Reals
1678   // ==================
1679
1680   else if (argc==8) {
1681     // On verifie que les deux points ne sont pas confondus
1682
1683     Standard_Real coord[6];
1684     for(Standard_Integer i=0;i<=2;i++){
1685       coord[i]=atof(argv[2+i]);
1686       coord[i+3]=atof(argv[5+i]);
1687     }
1688
1689     Handle(Geom_CartesianPoint ) myCartPointA=new Geom_CartesianPoint (coord[0],coord[1],coord[2] );
1690     Handle(Geom_CartesianPoint ) myCartPointB=new Geom_CartesianPoint (coord[3],coord[4],coord[5] );
1691
1692     Handle(AIS_Line) theAISLine= new AIS_Line(myCartPointA,myCartPointB );
1693     GetMapOfAIS().Bind(theAISLine,argv[1] );
1694     TheAISContext()->Display(theAISLine );
1695
1696   }
1697
1698   // Pas de parametres: Selection dans le viewer.
1699   // ============================================
1700
1701   else {
1702     TheAISContext()->OpenLocalContext();
1703     myCurrentIndex=TheAISContext()->IndexOfCurrentLocal();
1704
1705     // Active le mode Vertex.
1706     TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(1) );
1707     di<<" Select a vertex "<<"\n";
1708
1709     // Boucle d'attente waitpick.
1710     Standard_Integer argcc = 5;
1711     const char *buff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
1712     const char **argvv = (const char **) buff;
1713     while (ViewerMainLoop( argcc, argvv) ) { }
1714     // fin de la boucle
1715
1716     TopoDS_Shape ShapeA;
1717     for(TheAISContext()->InitSelected() ;TheAISContext()->MoreSelected() ;TheAISContext()->NextSelected() ) {
1718       ShapeA = TheAISContext()->SelectedShape();
1719     }
1720
1721     // ShapeA est un Vertex
1722     if (ShapeA.ShapeType()==TopAbs_VERTEX ) {
1723
1724       di<<" Select a different vertex."<<"\n";
1725
1726       TopoDS_Shape ShapeB;
1727       do {
1728
1729         // Boucle d'attente waitpick.
1730         Standard_Integer argccc = 5;
1731         const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
1732         const char **argvvv = (const char **) bufff;
1733         while (ViewerMainLoop( argccc, argvvv) ) { }
1734         // fin de la boucle
1735
1736         for(TheAISContext()->InitSelected() ;TheAISContext()->MoreSelected() ;TheAISContext()->NextSelected() ) {
1737           ShapeB = TheAISContext()->SelectedShape();
1738         }
1739
1740
1741       } while(ShapeB.IsSame(ShapeA) );
1742
1743       // Fermeture du context local
1744       TheAISContext()->CloseLocalContext(myCurrentIndex);
1745
1746       // Construction de la line
1747       gp_Pnt   A=BRep_Tool::Pnt(TopoDS::Vertex(ShapeA)  );
1748       gp_Pnt   B=BRep_Tool::Pnt(TopoDS::Vertex(ShapeB)  );
1749
1750       Handle(Geom_CartesianPoint ) myCartPointA=new Geom_CartesianPoint(A);
1751       Handle(Geom_CartesianPoint ) myCartPointB=new Geom_CartesianPoint(B);
1752
1753       Handle(AIS_Line) theAISLine= new AIS_Line(myCartPointA,myCartPointB );
1754       GetMapOfAIS().Bind(theAISLine,argv[1] );
1755       TheAISContext()->Display(theAISLine );
1756
1757     }
1758     else  {
1759       di<<"vline error."<<"\n";
1760     }
1761
1762   }
1763
1764   return 0;
1765 }
1766
1767 //==============================================================================
1768 // class   : FilledCircle
1769 // purpose : creates filled circle based on AIS_InteractiveObject
1770 //           and Geom_Circle.
1771 //           This class is used to check method Matches() of class
1772 //           Select3D_SensitiveCircle with member myFillStatus = Standard_True,
1773 //           because none of AIS classes provides creation of
1774 //           Select3D_SensitiveCircle with member myFillStatus = Standard_True
1775 //           (look method ComputeSelection() )
1776 //==============================================================================
1777
1778 Handle(Geom_Circle) CreateCircle(gp_Pnt theCenter, Standard_Real theRadius)
1779 {
1780   gp_Ax2 anAxes(theCenter, gp_Dir(gp_Vec(0., 0., 1.)));
1781   gp_Circ aCirc(anAxes, theRadius);
1782   Handle(Geom_Circle) aCircle = new Geom_Circle(aCirc);
1783   return aCircle;
1784 }
1785
1786 DEFINE_STANDARD_HANDLE(FilledCircle, AIS_InteractiveObject)
1787
1788 class FilledCircle : public AIS_InteractiveObject
1789 {
1790 public:
1791     // CASCADE RTTI
1792     DEFINE_STANDARD_RTTI(FilledCircle);
1793
1794     FilledCircle(gp_Pnt theCenter, Standard_Real theRadius);
1795     FilledCircle(Handle(Geom_Circle) theCircle);
1796
1797 private:
1798     TopoDS_Face ComputeFace();
1799
1800     // Virtual methods implementation
1801     void Compute (  const Handle(PrsMgr_PresentationManager3d)& thePresentationManager,
1802                   const Handle(Prs3d_Presentation)& thePresentation,
1803                   const Standard_Integer theMode);
1804
1805     void ComputeSelection (  const Handle(SelectMgr_Selection)& theSelection,
1806                            const Standard_Integer theMode);
1807
1808 protected:
1809     Handle(Geom_Circle) myCircle;
1810     Standard_Boolean myFilledStatus;
1811
1812 };
1813
1814 IMPLEMENT_STANDARD_HANDLE(FilledCircle, AIS_InteractiveObject)
1815 IMPLEMENT_STANDARD_RTTIEXT(FilledCircle, AIS_InteractiveObject)
1816
1817 FilledCircle::FilledCircle(gp_Pnt theCenter, Standard_Real theRadius)
1818 {
1819   myCircle = CreateCircle(theCenter, theRadius);
1820   myFilledStatus = Standard_True;
1821 }
1822
1823 FilledCircle::FilledCircle(Handle(Geom_Circle) theCircle)
1824 {
1825   myCircle = theCircle;
1826   myFilledStatus = Standard_True;
1827 }
1828
1829 TopoDS_Face FilledCircle::ComputeFace()
1830 {
1831   // Create edge from myCircle
1832   BRepBuilderAPI_MakeEdge anEdgeMaker(myCircle->Circ());
1833   TopoDS_Edge anEdge = anEdgeMaker.Edge();
1834
1835   // Create wire from anEdge
1836   BRepBuilderAPI_MakeWire aWireMaker(anEdge);
1837   TopoDS_Wire aWire = aWireMaker.Wire();
1838
1839   // Create face from aWire
1840   BRepBuilderAPI_MakeFace aFaceMaker(aWire);
1841   TopoDS_Face aFace = aFaceMaker.Face();
1842
1843   return aFace;
1844 }
1845
1846 void FilledCircle::Compute(const Handle_PrsMgr_PresentationManager3d &thePresentationManager,
1847                            const Handle_Prs3d_Presentation &thePresentation,
1848                            const Standard_Integer theMode)
1849 {
1850   thePresentation->Clear();
1851
1852   TopoDS_Face aFace = ComputeFace();
1853
1854   if (aFace.IsNull()) return;
1855   if (theMode != 0) return;
1856
1857   StdPrs_ShadedShape::Add(thePresentation, aFace, myDrawer);
1858 }
1859
1860 void FilledCircle::ComputeSelection(const Handle_SelectMgr_Selection &theSelection,
1861                                     const Standard_Integer theMode)
1862 {
1863   Handle(SelectMgr_EntityOwner) anEntityOwner = new SelectMgr_EntityOwner(this);
1864   Handle(Select3D_SensitiveCircle) aSensitiveCircle = new Select3D_SensitiveCircle(anEntityOwner,
1865       myCircle, myFilledStatus);
1866   theSelection->Add(aSensitiveCircle);
1867 }
1868
1869 //==============================================================================
1870 // Fonction  vcircle
1871 // -----------------  Uniquement par parametre. Pas de selection dans le viewer.
1872 //==============================================================================
1873
1874 //==============================================================================
1875 //function : VCircleBuilder
1876 //purpose  : Build an AIS_Circle
1877 //Draw arg : vcircle CircleName PlaneName PointName Radius IsFilled
1878 //                              PointName PointName PointName IsFilled
1879 //==============================================================================
1880
1881 void DisplayCircle (Handle (Geom_Circle) theGeomCircle,
1882                     TCollection_AsciiString theName,
1883                     Standard_Boolean isFilled)
1884 {
1885   Handle(AIS_InteractiveObject) aCircle;
1886   if (isFilled)
1887   {
1888     aCircle = new FilledCircle(theGeomCircle);
1889   }
1890   else
1891   {
1892     aCircle = new AIS_Circle(theGeomCircle);
1893   }
1894
1895   // Check if there is an object with given name
1896   // and remove it from context
1897   if (GetMapOfAIS().IsBound2(theName))
1898   {
1899     Handle(Standard_Transient) anObj = GetMapOfAIS().Find2(theName);
1900     Handle(AIS_InteractiveObject) anInterObj =
1901          Handle(AIS_InteractiveObject)::DownCast(anObj);
1902     TheAISContext()->Remove(anInterObj, Standard_False);
1903     GetMapOfAIS().UnBind2(theName);
1904    }
1905
1906    // Bind the circle to its name
1907    GetMapOfAIS().Bind(aCircle, theName);
1908
1909    // Display the circle
1910    TheAISContext()->Display(aCircle);
1911
1912 }
1913
1914 static int VCircleBuilder(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
1915 {
1916   Standard_Integer myCurrentIndex;
1917   // Verification of the arguments
1918   if (argc>6 || argc<2)
1919   {
1920     std::cout << "vcircle error: expect 4 arguments.\n";
1921     return 1; // TCL_ERROR
1922   }
1923   TheAISContext()->CloseAllContexts();
1924
1925   // There are all arguments
1926   if (argc == 6)
1927   {
1928     // Get arguments
1929     TCollection_AsciiString aName(argv[1]);
1930     Standard_Boolean isFilled = (Standard_Boolean)atoi(argv[5]);
1931
1932     Handle(AIS_InteractiveObject) theShapeA;
1933     Handle(AIS_InteractiveObject) theShapeB;
1934
1935     theShapeA =
1936       Handle(AIS_InteractiveObject)::DownCast(GetMapOfAIS().Find2(argv[2]));
1937     theShapeB =
1938       Handle(AIS_InteractiveObject)::DownCast(GetMapOfAIS().Find2(argv[3]));
1939
1940
1941     // Arguments: AIS_Point AIS_Point AIS_Point
1942     // ========================================
1943     if (!theShapeA.IsNull() && !theShapeB.IsNull() &&
1944       theShapeA->Type()==AIS_KOI_Datum && theShapeA->Signature()==1)
1945     {
1946       if (theShapeB->Type()!=AIS_KOI_Datum || theShapeB->Signature()!=1 )
1947       {
1948         std::cout << "vcircle error: 2d argument is unexpected to be a point.\n";
1949         return 1; // TCL_ERROR
1950       }
1951       // The third object must be a point
1952       Handle(AIS_InteractiveObject) theShapeC =
1953         Handle(AIS_InteractiveObject)::DownCast(GetMapOfAIS().Find2(argv[4]));
1954       if (theShapeC.IsNull() ||
1955         theShapeC->Type()!=AIS_KOI_Datum || theShapeC->Signature()!=1 )
1956       {
1957         std::cout << "vcircle error: 3d argument is unexpected to be a point.\n";
1958         return 1; // TCL_ERROR
1959       }
1960         // tag
1961         // Verify that the three points are different
1962         Handle(AIS_Point) theAISPointA = Handle(AIS_Point)::DownCast(theShapeA);
1963         Handle(AIS_Point) theAISPointB = Handle(AIS_Point)::DownCast(theShapeB);
1964         Handle(AIS_Point) theAISPointC = Handle(AIS_Point)::DownCast(theShapeC);
1965
1966         Handle(Geom_Point) myGeomPointA = theAISPointA->Component();
1967         Handle(Geom_CartesianPoint) myCartPointA =
1968           Handle(Geom_CartesianPoint)::DownCast(myGeomPointA);
1969
1970         Handle(Geom_Point) myGeomPointB = theAISPointB->Component();
1971         Handle(Geom_CartesianPoint) myCartPointB =
1972           Handle(Geom_CartesianPoint)::DownCast(myGeomPointB);
1973
1974         Handle(Geom_Point) myGeomPointC = theAISPointC->Component();
1975         Handle(Geom_CartesianPoint) myCartPointC =
1976           Handle(Geom_CartesianPoint)::DownCast(myGeomPointC);
1977
1978         // Test A=B
1979         if (abs(myCartPointA->X()-myCartPointB->X()) <= Precision::Confusion() &&
1980           abs(myCartPointA->Y()-myCartPointB->Y()) <= Precision::Confusion() &&
1981           abs(myCartPointA->Z()-myCartPointB->Z()) <= Precision::Confusion() )
1982         {
1983           std::cout << "vcircle error: Same points.\n";
1984           return 1; // TCL_ERROR
1985         }
1986         // Test A=C
1987         if (abs(myCartPointA->X()-myCartPointC->X()) <= Precision::Confusion() &&
1988           abs(myCartPointA->Y()-myCartPointC->Y()) <= Precision::Confusion() &&
1989           abs(myCartPointA->Z()-myCartPointC->Z()) <= Precision::Confusion() )
1990         {
1991           std::cout << "vcircle error: Same points.\n";
1992           return 1; // TCL_ERROR
1993         }
1994         // Test B=C
1995         if (abs(myCartPointB->X()-myCartPointC->X()) <= Precision::Confusion() &&
1996           abs(myCartPointB->Y()-myCartPointC->Y()) <= Precision::Confusion() &&
1997           abs(myCartPointB->Z()-myCartPointC->Z()) <= Precision::Confusion() )
1998         {
1999           std::cout << "vcircle error: Same points.\n";
2000           return 1;// TCL_ERROR
2001         }
2002         // Construction of the circle
2003         GC_MakeCircle Cir = GC_MakeCircle (myCartPointA->Pnt(),
2004           myCartPointB->Pnt(), myCartPointC->Pnt() );
2005         Handle (Geom_Circle) theGeomCircle;
2006         try
2007         {
2008           theGeomCircle = Cir.Value();
2009         }
2010         catch (StdFail_NotDone)
2011         {
2012           std::cout << "vcircle error: can't create circle\n";
2013           return -1; // TCL_ERROR
2014         }
2015
2016         DisplayCircle(theGeomCircle, aName, isFilled);
2017     }
2018
2019     // Arguments: AIS_Plane AIS_Point Real
2020     // ===================================
2021     else if (theShapeA->Type() == AIS_KOI_Datum &&
2022       theShapeA->Signature() == 7 )
2023     {
2024       if (theShapeB->Type() != AIS_KOI_Datum ||
2025         theShapeB->Signature() != 1 )
2026       {
2027         std::cout << "vcircle error: 2d element is a unexpected to be a point.\n";
2028         return 1; // TCL_ERROR
2029       }
2030       // Ñheck that the radius is >= 0
2031       if (atof(argv[4]) <= 0 )
2032       {
2033         std::cout << "vcircle error: the radius must be >=0.\n";
2034         return 1; // TCL_ERROR
2035       }
2036
2037       // Recover the normal to the plane
2038       Handle(AIS_Plane) theAISPlane = Handle(AIS_Plane)::DownCast(theShapeA);
2039       Handle(AIS_Point) theAISPointB = Handle(AIS_Point)::DownCast(theShapeB);
2040
2041       Handle(Geom_Plane) myGeomPlane = theAISPlane->Component();
2042       Handle(Geom_Point) myGeomPointB = theAISPointB->Component();
2043       Handle(Geom_CartesianPoint) myCartPointB =
2044         Handle(Geom_CartesianPoint)::DownCast(myGeomPointB);
2045
2046       gp_Pln mygpPlane = myGeomPlane->Pln();
2047       gp_Ax1 thegpAxe = mygpPlane.Axis();
2048       gp_Dir theDir = thegpAxe.Direction();
2049       gp_Pnt theCenter = myCartPointB->Pnt();
2050       Standard_Real TheR = atof(argv[4]);
2051       GC_MakeCircle Cir = GC_MakeCircle (theCenter, theDir ,TheR);
2052       Handle (Geom_Circle) theGeomCircle;
2053       try
2054       {
2055         theGeomCircle = Cir.Value();
2056       }
2057       catch (StdFail_NotDone)
2058       {
2059         std::cout << "vcircle error: can't create circle\n";
2060         return -1; // TCL_ERROR
2061       }
2062
2063       DisplayCircle(theGeomCircle, aName, isFilled);
2064
2065     }
2066
2067     // Error
2068     else
2069     {
2070       std::cout << "vcircle error: 1st argument is a unexpected type.\n";
2071       return 1; // TCL_ERROR
2072     }
2073
2074   }
2075   // No arguments: selection in the viewer
2076   // =========================================
2077   else
2078   {
2079     // Get the name of the circle
2080     TCollection_AsciiString aName(argv[1]);
2081
2082     TheAISContext()->OpenLocalContext();
2083     myCurrentIndex = TheAISContext()->IndexOfCurrentLocal();
2084
2085     // Activate selection mode for vertices and faces
2086     TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(1) );
2087     TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(4) );
2088     std::cout << " Select a vertex or a face\n";
2089
2090     // Wait for picking
2091     Standard_Integer argcc = 5;
2092     const char *buff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
2093     const char **argvv = (const char **) buff;
2094     while (ViewerMainLoop( argcc, argvv) ) { }
2095     // end of the loop
2096
2097     TopoDS_Shape ShapeA;
2098     for(TheAISContext()->InitSelected();
2099       TheAISContext()->MoreSelected();
2100       TheAISContext()->NextSelected() )
2101     {
2102       ShapeA = TheAISContext()->SelectedShape();
2103     }
2104
2105     // ShapeA is a Vertex
2106     if (ShapeA.ShapeType() == TopAbs_VERTEX )
2107     {
2108       TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(4) );
2109       std::cout << " Select a different vertex\n";
2110
2111       TopoDS_Shape ShapeB;
2112       do
2113       {
2114         // Wait for picking
2115         Standard_Integer argccc = 5;
2116         const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
2117         const char **argvvv = (const char **) bufff;
2118         while (ViewerMainLoop( argccc, argvvv) ) { }
2119         // end of the loop
2120
2121         for(TheAISContext()->InitSelected();
2122           TheAISContext()->MoreSelected();
2123           TheAISContext()->NextSelected() )
2124         {
2125           ShapeB = TheAISContext()->SelectedShape();
2126         }
2127       } while(ShapeB.IsSame(ShapeA) );
2128
2129       // Selection of ShapeC
2130       std::cout << " Select the last vertex\n";
2131       TopoDS_Shape ShapeC;
2132       do
2133       {
2134         // Wait for picking
2135         Standard_Integer argcccc = 5;
2136         const char *buffff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
2137         const char **argvvvv = (const char **) buffff;
2138         while (ViewerMainLoop( argcccc, argvvvv) ) { }
2139         // end of the loop
2140
2141         for(TheAISContext()->InitSelected();
2142           TheAISContext()->MoreSelected();
2143           TheAISContext()->NextSelected() )
2144         {
2145           ShapeC = TheAISContext()->SelectedShape();
2146         }
2147       } while(ShapeC.IsSame(ShapeA) || ShapeC.IsSame(ShapeB) );
2148
2149       // Get isFilled
2150       Standard_Boolean isFilled;
2151       std::cout << "Enter filled status (0 or 1)\n";
2152       cin >> isFilled;
2153
2154       // Close the local context
2155       TheAISContext()->CloseLocalContext(myCurrentIndex);
2156
2157       // Construction of the circle
2158       gp_Pnt A = BRep_Tool::Pnt(TopoDS::Vertex(ShapeA));
2159       gp_Pnt B = BRep_Tool::Pnt(TopoDS::Vertex(ShapeB));
2160       gp_Pnt C = BRep_Tool::Pnt(TopoDS::Vertex(ShapeC));
2161
2162       GC_MakeCircle Cir = GC_MakeCircle (A, B, C);
2163       Handle (Geom_Circle) theGeomCircle;
2164       try
2165       {
2166         theGeomCircle = Cir.Value();
2167       }
2168       catch (StdFail_NotDone)
2169       {
2170         std::cout << "vcircle error: can't create circle\n";
2171         return -1; // TCL_ERROR
2172       }
2173
2174       DisplayCircle(theGeomCircle, aName, isFilled);
2175
2176     }
2177     // Shape is a face
2178     else
2179     {
2180       std::cout << " Select a vertex (in your face)\n";
2181       TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(4) );
2182
2183       TopoDS_Shape ShapeB;
2184       // Wait for picking
2185       Standard_Integer argccc = 5;
2186       const char *bufff[] = { "VPick", "X", "VPickY","VPickZ", "VPickShape" };
2187       const char **argvvv = (const char **) bufff;
2188       while (ViewerMainLoop( argccc, argvvv) ) { }
2189       // end of the loop
2190
2191       for(TheAISContext()->InitSelected();
2192         TheAISContext()->MoreSelected();
2193         TheAISContext()->NextSelected() )
2194       {
2195         ShapeB = TheAISContext()->SelectedShape();
2196       }
2197
2198       // Recover the radius
2199       Standard_Real theRad;
2200       do
2201       {
2202         std::cout << " Enter the value of the radius:\n";
2203         cin >> theRad;
2204       } while (theRad <= 0);
2205
2206       // Get filled status
2207       Standard_Boolean isFilled;
2208       std::cout << "Enter filled status (0 or 1)\n";
2209       cin >> isFilled;
2210
2211       // Close the local context
2212       TheAISContext()->CloseLocalContext(myCurrentIndex);
2213       // Construction of the circle
2214
2215       // Recover the normal to the plane. tag
2216       TopoDS_Face myFace = TopoDS::Face(ShapeA);
2217       BRepAdaptor_Surface mySurface (myFace, Standard_False);
2218       gp_Pln myPlane = mySurface.Plane();
2219       Handle(Geom_Plane) theGeomPlane = new Geom_Plane (myPlane);
2220       gp_Pln mygpPlane = theGeomPlane->Pln();
2221       gp_Ax1 thegpAxe = mygpPlane.Axis();
2222       gp_Dir theDir = thegpAxe.Direction();
2223
2224       // Recover the center
2225       gp_Pnt theCenter = BRep_Tool::Pnt(TopoDS::Vertex(ShapeB));
2226
2227       // Ñonstruct the circle
2228       GC_MakeCircle Cir = GC_MakeCircle (theCenter, theDir ,theRad);
2229       Handle (Geom_Circle) theGeomCircle;
2230       try
2231       {
2232         theGeomCircle = Cir.Value();
2233       }
2234       catch (StdFail_NotDone)
2235       {
2236         std::cout << "vcircle error: can't create circle\n";
2237         return -1; // TCL_ERROR
2238       }
2239
2240       DisplayCircle(theGeomCircle, aName, isFilled);
2241
2242     }
2243
2244   }
2245
2246   return 0;
2247 }
2248
2249
2250 //===============================================================================================
2251 //function : VDrawText
2252 //author   : psn
2253 //purpose  : Create a text.
2254 //Draw arg : vdrawtext  name  [X] [Y] [Z] [R] [G] [B] [hor_align] [ver_align] [angle] [zoomable]
2255 //===============================================================================================
2256 #include <Graphic3d_Group.hxx>
2257 #include <Graphic3d_Structure.hxx>
2258 #include <Graphic3d_AspectText3d.hxx>
2259 #include <Graphic2d_GraphicObject.hxx>
2260 #include <Graphic3d_Array1OfVertex.hxx>
2261 #include <Graphic3d_AspectFillArea3d.hxx>
2262 #include <Graphic3d_StructureManager.hxx>
2263 #include <Graphic3d_VerticalTextAlignment.hxx>
2264 #include <Graphic3d_HorizontalTextAlignment.hxx>
2265
2266 #include <Font_NameOfFont.hxx>
2267
2268 #include <Visual3d_ViewManager.hxx>
2269 #include <ViewerTest_Tool.ixx>
2270
2271 #include <Standard_DefineHandle.hxx>
2272
2273 #include <Prs3d_Root.hxx>
2274 #include <Prs3d_Text.hxx>
2275 #include <Prs3d_TextAspect.hxx>
2276 #include <Prs3d_ShadingAspect.hxx>
2277 #include <PrsMgr_PresentationManager3d.hxx>
2278
2279 #include <TCollection_ExtendedString.hxx>
2280 #include <TCollection_AsciiString.hxx>
2281
2282 #include <gp_Pnt.hxx>
2283 #include <Quantity_NameOfColor.hxx>
2284 #include <Quantity_Color.hxx>
2285
2286
2287 DEFINE_STANDARD_HANDLE(MyTextClass, AIS_InteractiveObject)
2288
2289 class MyTextClass:public AIS_InteractiveObject
2290 {
2291 public:
2292   // CASCADE RTTI
2293   DEFINE_STANDARD_RTTI(MyTextClass );
2294
2295   MyTextClass(){};
2296
2297   MyTextClass
2298     (
2299       const TCollection_ExtendedString& , const gp_Pnt& ,
2300       Quantity_Color color,
2301       Standard_Integer aHJust,
2302       Standard_Integer aVJust ,
2303       Standard_Real Angle ,
2304       Standard_Boolean Zoom ,
2305       Standard_Real  Height,
2306       Font_FontAspect FontAspect,
2307       Standard_CString Font
2308     );
2309
2310 private:
2311
2312   void Compute (  const Handle(PrsMgr_PresentationManager3d)& aPresentationManager,
2313                   const Handle(Prs3d_Presentation)& aPresentation,
2314                   const Standard_Integer aMode);
2315
2316   void ComputeSelection (  const Handle(SelectMgr_Selection)& aSelection,
2317                            const Standard_Integer aMode){} ;
2318
2319 protected:
2320   TCollection_ExtendedString          aText;
2321   gp_Pnt                              aPosition;
2322   Standard_Real                       Red;
2323   Standard_Real                       Green;
2324   Standard_Real                       Blue;
2325   Standard_Real                       aAngle;
2326   Standard_Real                       aHeight;
2327   Standard_Boolean                    aZoomable;
2328   Quantity_Color                      aColor;
2329   Standard_CString                    aFont;
2330   Font_FontAspect                     aFontAspect;
2331   Graphic3d_HorizontalTextAlignment   aHJustification;
2332   Graphic3d_VerticalTextAlignment     aVJustification;
2333 };
2334
2335
2336
2337 IMPLEMENT_STANDARD_HANDLE(MyTextClass, AIS_InteractiveObject)
2338 IMPLEMENT_STANDARD_RTTIEXT(MyTextClass, AIS_InteractiveObject)
2339
2340
2341 MyTextClass::MyTextClass( const TCollection_ExtendedString& text, const gp_Pnt& position,
2342                           Quantity_Color    color       = Quantity_NOC_YELLOW,
2343                           Standard_Integer  aHJust      = Graphic3d_HTA_LEFT,
2344                           Standard_Integer  aVJust      = Graphic3d_VTA_BOTTOM,
2345                           Standard_Real     angle       = 0.0 ,
2346                           Standard_Boolean  zoomable    = Standard_True,
2347                           Standard_Real     height      = 12.,
2348                           Font_FontAspect   fontAspect  = Font_FA_Regular,
2349                           Standard_CString  font        = "Courier")
2350 {
2351   aText           = text;
2352   aPosition       = position;
2353   aHJustification = Graphic3d_HorizontalTextAlignment(aHJust);
2354   aVJustification = Graphic3d_VerticalTextAlignment(aVJust);
2355   aAngle          = angle;
2356   aZoomable       = zoomable;
2357   aHeight         = height;
2358   aColor          = color;
2359   aFontAspect     = fontAspect;
2360   aFont           = font;
2361 };
2362
2363
2364
2365 //////////////////////////////////////////////////////////////////////////////
2366 void MyTextClass::Compute(const Handle(PrsMgr_PresentationManager3d)& aPresentationManager,
2367                           const Handle(Prs3d_Presentation)& aPresentation,
2368                           const Standard_Integer aMode)
2369 {
2370
2371   aPresentation->Clear();
2372
2373   Handle_Prs3d_TextAspect asp = myDrawer->TextAspect();
2374
2375   asp->SetFont(aFont);
2376   asp->SetColor(aColor);
2377   asp->SetHeight(aHeight); // I am changing the myHeight value
2378
2379   asp->SetHorizontalJustification(aHJustification);
2380   asp->SetVerticalJustification(aVJustification);
2381   asp->Aspect()->SetTextZoomable(aZoomable);
2382   asp->Aspect()->SetTextAngle(aAngle);
2383   asp->Aspect()->SetTextFontAspect(aFontAspect);
2384   Prs3d_Text::Draw(aPresentation, asp, aText, aPosition);
2385
2386   /* This comment code is worked
2387   Handle(Graphic3d_Group) TheGroup = Prs3d_Root::CurrentGroup(aPresentation);
2388   Handle(Graphic3d_AspectFillArea3d) aspect = myDrawer->ShadingAspect()->Aspect();
2389   Graphic3d_Vertex vertices_text;
2390   vertices_text.SetCoord(aPosition.X(),aPosition.Y(),aPosition.Y());
2391   TheGroup->SetPrimitivesAspect(aspect);
2392   TheGroup->BeginPrimitives();
2393   TheGroup->Text(aText,vertices_text,aHeight,Standard_True);
2394   TheGroup->EndPrimitives();
2395   */
2396 };
2397
2398 static int VDrawText (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
2399 {
2400   // Check arguments
2401   if (argc < 14)
2402   {
2403     di<<"Error: "<<argv[0]<<" - invalid number of arguments\n";
2404     di<<"Usage: type help "<<argv[0]<<"\n";
2405     return 1; //TCL_ERROR
2406   }
2407
2408   Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
2409
2410   // Create 3D view if it doesn't exist
2411   if ( aContext.IsNull() )
2412   {
2413     ViewerTest::ViewerInit();
2414     aContext = ViewerTest::GetAISContext();
2415     if( aContext.IsNull() )
2416     {
2417       di << "Error: Cannot create a 3D view\n";
2418       return 1; //TCL_ERROR
2419     }
2420   }
2421
2422   // Text position
2423   const Standard_Real X = atof(argv[2]);
2424   const Standard_Real Y = atof(argv[3]);
2425   const Standard_Real Z = atof(argv[4]);
2426   const gp_Pnt pnt(X,Y,Z);
2427
2428   // Text color
2429   const Quantity_Parameter R = atof(argv[5])/255.;
2430   const Quantity_Parameter G = atof(argv[6])/255.;
2431   const Quantity_Parameter B = atof(argv[7])/255.;
2432   const Quantity_Color aColor( R, G, B, Quantity_TOC_RGB );
2433
2434   // Text alignment
2435   const int hor_align = atoi(argv[8]);
2436   const int ver_align = atoi(argv[9]);
2437
2438   // Text angle
2439   const Standard_Real angle = atof(argv[10]);
2440
2441   // Text zooming
2442   const Standard_Boolean zoom = atoi(argv[11]);
2443
2444   // Text height
2445   const Standard_Real height = atof(argv[12]);
2446
2447   // Text aspect
2448   const Font_FontAspect aspect = Font_FontAspect(atoi(argv[13]));
2449
2450   // Text font
2451   TCollection_AsciiString font;
2452   if(argc < 15)
2453     font.AssignCat("Courier");
2454   else
2455     font.AssignCat(argv[14]);
2456
2457   // Text is multibyte
2458   const Standard_Boolean isMultibyte = (argc < 16)? Standard_False : (atoi(argv[15]) != 0);
2459
2460   // Read text string
2461   TCollection_ExtendedString name;
2462   if (isMultibyte)
2463   {
2464     const char *str = argv[1];
2465     while ( *str || *(str+1)=='\x0A' || *(str+1)=='\x0B' || *(str+1)=='\x0C' || *(str+1)=='\x0D'
2466                  || *(str+1)=='\x07' || *(str+1)=='\x08' || *(str+1)=='\x09' )
2467     {
2468       unsigned short c1 = *str++;
2469       unsigned short c2 = *str++;
2470       if (!c2) break;
2471       name += (Standard_ExtCharacter)((c1 << 8) | c2);
2472     }
2473   }
2474   else
2475   {
2476     name += argv[1];
2477   }
2478
2479   if (name.Length())
2480   {
2481     Handle(MyTextClass) myT = new MyTextClass(name,pnt,aColor,hor_align,ver_align,angle,zoom,height,aspect,font.ToCString());
2482     aContext->Display(myT,Standard_True);
2483   }
2484
2485   return 0;
2486 }
2487
2488 #include <math.h>
2489 #include <gp_Pnt.hxx>
2490 #include <Graphic3d_ArrayOfPoints.hxx>
2491 #include <Graphic3d_ArrayOfPrimitives.hxx>
2492 #include <Graphic3d_Array1OfVertex.hxx>
2493 #include <Graphic3d_ArrayOfTriangles.hxx>
2494 #include <Poly_Array1OfTriangle.hxx>
2495 #include <Poly_Triangle.hxx>
2496 #include <Poly_Triangulation.hxx>
2497 #include <TColgp_Array1OfPnt.hxx>
2498 #include <TShort_Array1OfShortReal.hxx>
2499 #include <TShort_HArray1OfShortReal.hxx>
2500
2501 #include <AIS_Triangulation.hxx>
2502 #include <Aspect_GraphicDevice.hxx>
2503 #include <StdPrs_ToolShadedShape.hxx>
2504 #include <Poly_Connect.hxx>
2505 #include <TColgp_Array1OfDir.hxx>
2506 #include <Graphic3d_GraphicDriver.hxx>
2507
2508 #include <TColStd_Array1OfInteger.hxx>
2509 #include <TColStd_HArray1OfInteger.hxx>
2510 #include <Prs3d_ShadingAspect.hxx>
2511 #include <Graphic3d_MaterialAspect.hxx>
2512 #include <Graphic3d_AspectFillArea3d.hxx>
2513
2514 #include <BRepPrimAPI_MakeCylinder.hxx>
2515 #include <TopoDS_Shape.hxx>
2516 #include <TopExp_Explorer.hxx>
2517 #include <TopAbs.hxx>
2518 #include <StdSelect_ShapeTypeFilter.hxx>
2519
2520
2521 //===============================================================================================
2522 //function : CalculationOfSphere
2523 //author   : psn
2524 //purpose  : Create a Sphere
2525 //===============================================================================================
2526
2527 Handle( Poly_Triangulation ) CalculationOfSphere( double X , double Y , double Z ,
2528                                                   int res ,
2529                                                   double Radius ){
2530   double mRadius = Radius;
2531   double mCenter[3] = {X,Y,Z};
2532   int mThetaResolution;
2533   int mPhiResolution;
2534   double mStartTheta = 0;//StartTheta;
2535   double mEndTheta = 360;//EndTheta;
2536   double mStartPhi = 0;//StartPhi;
2537   double mEndPhi = 180;//EndPhi;
2538   res = res < 4 ? 4 : res;
2539
2540   mThetaResolution = res;
2541   mPhiResolution = res;
2542
2543   int i, j;
2544   int jStart, jEnd, numOffset;
2545   int numPts, numPolys;
2546   double x[3], n[3], deltaPhi, deltaTheta, phi, theta, radius;
2547   double startTheta, endTheta, startPhi, endPhi;
2548   int base, numPoles=0, thetaResolution, phiResolution;
2549
2550   int pts[3];
2551   int piece = -1;
2552   int numPieces = 1;
2553   if ( numPieces > mThetaResolution ) {
2554     numPieces = mThetaResolution;
2555   }
2556
2557   int localThetaResolution =  mThetaResolution;
2558   double localStartTheta =  mStartTheta;
2559   double localEndTheta =  mEndTheta;
2560
2561   while ( localEndTheta < localStartTheta ) {
2562     localEndTheta += 360.0;
2563   }
2564
2565   deltaTheta = (localEndTheta - localStartTheta) / localThetaResolution;
2566
2567   // Change the ivars based on pieces.
2568   int start, end;
2569   start = piece * localThetaResolution / numPieces;
2570   end = (piece+1) * localThetaResolution / numPieces;
2571   localEndTheta = localStartTheta + (double)(end) * deltaTheta;
2572   localStartTheta = localStartTheta + (double)(start) * deltaTheta;
2573   localThetaResolution = end - start;
2574
2575   numPts =  mPhiResolution * localThetaResolution + 2;
2576   numPolys =  mPhiResolution * 2 * localThetaResolution;
2577
2578   // Create north pole if needed
2579   int number_point = 0;
2580   int number_pointArray = 0;
2581
2582   if ( mStartPhi <= 0.0 ) {
2583     number_pointArray++;
2584     numPoles++;
2585   }
2586   if ( mEndPhi >= 180.0 ) {
2587     number_pointArray++;
2588     numPoles++;
2589   }
2590
2591   // Check data, determine increments, and convert to radians
2592   startTheta = (localStartTheta < localEndTheta ? localStartTheta : localEndTheta);
2593   startTheta *= M_PI  / 180.0;
2594   endTheta = (localEndTheta > localStartTheta ? localEndTheta : localStartTheta);
2595   endTheta *= M_PI  / 180.0;
2596
2597
2598   startPhi = ( mStartPhi <  mEndPhi ?  mStartPhi :  mEndPhi);
2599   startPhi *= M_PI  / 180.0;
2600   endPhi = ( mEndPhi >  mStartPhi ?  mEndPhi :  mStartPhi);
2601   endPhi *= M_PI  / 180.0;
2602
2603   phiResolution =  mPhiResolution - numPoles;
2604   deltaPhi = (endPhi - startPhi) / ( mPhiResolution - 1);
2605   thetaResolution = localThetaResolution;
2606   if ( fabs(localStartTheta - localEndTheta) < 360.0 ) {
2607     ++localThetaResolution;
2608   }
2609   deltaTheta = (endTheta - startTheta) / thetaResolution;
2610
2611   jStart = ( mStartPhi <= 0.0 ? 1 : 0);
2612   jEnd = ( mEndPhi >= 180.0 ?  mPhiResolution - 1 :  mPhiResolution);
2613
2614   // Create intermediate points
2615   for ( i = 0; i < localThetaResolution; i++ ) {
2616     for ( j = jStart; j < jEnd; j++ ) {
2617         number_pointArray++;
2618     }
2619   }
2620
2621   //Generate mesh connectivity
2622   base = phiResolution * localThetaResolution;
2623
2624   int number_triangle = 0 ;
2625   if ( mStartPhi <= 0.0 ) { // around north pole
2626     number_triangle += localThetaResolution;
2627   }
2628
2629   if ( mEndPhi >= 180.0 ) { // around south pole
2630     number_triangle += localThetaResolution;
2631   }
2632
2633   // bands in-between poles
2634   for ( i=0; i < localThetaResolution; i++){
2635     for ( j=0; j < (phiResolution-1); j++){
2636        number_triangle +=2;
2637     }
2638   }
2639
2640   Handle( Poly_Triangulation ) polyTriangulation = new Poly_Triangulation(number_pointArray, number_triangle, false);
2641   TColgp_Array1OfPnt& PointsOfArray = polyTriangulation->ChangeNodes();
2642   Poly_Array1OfTriangle& pArrayTriangle = polyTriangulation->ChangeTriangles();
2643
2644   if (  mStartPhi <= 0.0 ){
2645       x[0] =  mCenter[0];
2646       x[1] =  mCenter[1];
2647       x[2] =  mCenter[2] +  mRadius;
2648       PointsOfArray.SetValue(1,gp_Pnt(x[0],x[1],x[2]));
2649   }
2650
2651   // Create south pole if needed
2652   if (  mEndPhi >= 180.0 ){
2653       x[0] =  mCenter[0];
2654       x[1] =  mCenter[1];
2655       x[2] =  mCenter[2] -  mRadius;
2656       PointsOfArray.SetValue(2,gp_Pnt(x[0],x[1],x[2]));
2657   }
2658
2659   number_point = 3;
2660   for ( i=0; i < localThetaResolution; i++){
2661     theta = localStartTheta * M_PI / 180.0 + i*deltaTheta;
2662     for ( j = jStart; j < jEnd; j++){
2663         phi = startPhi + j*deltaPhi;
2664         radius =  mRadius * sin((double)phi);
2665         n[0] = radius * cos((double)theta);
2666         n[1] = radius * sin((double)theta);
2667         n[2] =  mRadius * cos((double)phi);
2668         x[0] = n[0] +  mCenter[0];
2669         x[1] = n[1] +  mCenter[1];
2670         x[2] = n[2] +  mCenter[2];
2671         PointsOfArray.SetValue(number_point,gp_Pnt(x[0],x[1],x[2]));
2672         number_point++;
2673       }
2674     }
2675
2676   numPoles = 3;
2677   number_triangle = 1;
2678   if ( mStartPhi <= 0.0 ){// around north pole
2679     for (i=0; i < localThetaResolution; i++){
2680         pts[0] = phiResolution*i + numPoles;
2681         pts[1] = (phiResolution*(i+1) % base) + numPoles;
2682         pts[2] = 1;
2683         pArrayTriangle.SetValue(number_triangle,Poly_Triangle(pts[0],pts[1],pts[2]));
2684         number_triangle++;
2685       }
2686     }
2687
2688   if (  mEndPhi >= 180.0 ){ // around south pole
2689     numOffset = phiResolution - 1 + numPoles;
2690     for (i=0; i < localThetaResolution; i++){
2691         pts[0] = phiResolution*i + numOffset;
2692         pts[2] = ((phiResolution*(i+1)) % base) + numOffset;
2693         pts[1] = numPoles - 1;
2694         pArrayTriangle.SetValue(number_triangle,Poly_Triangle(pts[0],pts[1],pts[2]));
2695         number_triangle++;
2696       }
2697     }
2698
2699   // bands in-between poles
2700
2701   for (i=0; i < localThetaResolution; i++){
2702     for (j=0; j < (phiResolution-1); j++){
2703         pts[0] = phiResolution*i + j + numPoles;
2704         pts[1] = pts[0] + 1;
2705         pts[2] = ((phiResolution*(i+1)+j) % base) + numPoles + 1;
2706         pArrayTriangle.SetValue(number_triangle,Poly_Triangle(pts[0],pts[1],pts[2]));
2707         number_triangle++;
2708         pts[1] = pts[2];
2709         pts[2] = pts[1] - 1;
2710         pArrayTriangle.SetValue(number_triangle,Poly_Triangle(pts[0],pts[1],pts[2]));
2711         number_triangle++;
2712       }
2713     }
2714
2715   Poly_Connect* pc = new Poly_Connect(polyTriangulation);
2716
2717   Handle(TShort_HArray1OfShortReal) Normals = new TShort_HArray1OfShortReal(1, polyTriangulation->NbNodes() * 3);
2718
2719   Standard_Integer index[3];
2720   Standard_Real Tol = Precision::Confusion();
2721
2722   gp_Dir Nor;
2723   for (i = PointsOfArray.Lower(); i <= PointsOfArray.Upper(); i++) {
2724       gp_XYZ eqPlan(0, 0, 0);
2725       for ( pc->Initialize(i); pc->More(); pc->Next()) {
2726         pArrayTriangle(pc->Value()).Get(index[0], index[1], index[2]);
2727         gp_XYZ v1(PointsOfArray(index[1]).Coord()-PointsOfArray(index[0]).Coord());
2728         gp_XYZ v2(PointsOfArray(index[2]).Coord()-PointsOfArray(index[1]).Coord());
2729         gp_XYZ vv = v1^v2;
2730         Standard_Real mod = vv.Modulus();
2731         if(mod < Tol) continue;
2732         eqPlan += vv/mod;
2733       }
2734
2735       Standard_Real modmax = eqPlan.Modulus();
2736
2737       if(modmax > Tol)
2738         Nor = gp_Dir(eqPlan);
2739       else
2740         Nor = gp_Dir(0., 0., 1.);
2741
2742       Standard_Integer j = (i - PointsOfArray.Lower()) * 3;
2743       Normals->SetValue(j + 1, (Standard_ShortReal)Nor.X());
2744       Normals->SetValue(j + 2, (Standard_ShortReal)Nor.Y());
2745       Normals->SetValue(j + 3, (Standard_ShortReal)Nor.Z());
2746   }
2747
2748   delete pc;
2749   polyTriangulation->SetNormals(Normals);
2750
2751   return polyTriangulation;
2752 }
2753
2754 //===============================================================================================
2755 //function : VDrawSphere
2756 //author   : psn
2757 //purpose  : Create an AIS shape.
2758 //===============================================================================================
2759 static int VDrawSphere (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
2760 {
2761   // check for errors
2762   Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext();
2763   if (aContextAIS.IsNull())
2764   {
2765     std::cout << "Call vinit before!\n";
2766     return 1;
2767   }
2768   else if (argc < 3)
2769   {
2770     std::cout << "Use: " << argv[0]
2771               << " shapeName Fineness [X=0.0 Y=0.0 Z=0.0] [Radius=100.0] [ToEnableVBO=1] [NumberOfViewerUpdate=1] [ToShowEdges=0]\n";
2772     return 1;
2773   }
2774
2775   // read the arguments
2776   TCollection_AsciiString aShapeName (argv[1]);
2777   Standard_Integer aResolution = atoi (argv[2]);
2778   Standard_Real aCenterX = (argc > 5) ? atof (argv[3]) : 0.0;
2779   Standard_Real aCenterY = (argc > 5) ? atof (argv[4]) : 0.0;
2780   Standard_Real aCenterZ = (argc > 5) ? atof (argv[5]) : 0.0;
2781   Standard_Real aRadius =  (argc > 6) ? atof (argv[6]) : 100.0;
2782   Standard_Boolean toShowEdges =  (argc > 7) ? atoi (argv[7]) : Standard_False;
2783
2784   // remove AIS object with given name from map
2785   VDisplayAISObject (aShapeName, Handle(AIS_InteractiveObject)());
2786
2787   std::cout << "Compute Triangulation...\n";
2788   Handle(AIS_Triangulation) aShape
2789     = new AIS_Triangulation (CalculationOfSphere (aCenterX, aCenterY, aCenterZ,
2790                                                   aResolution,
2791                                                   aRadius));
2792   Standard_Integer aNumberPoints    = aShape->GetTriangulation()->Nodes().Length();
2793   Standard_Integer aNumberTriangles = aShape->GetTriangulation()->Triangles().Length();
2794
2795   // stupid initialization of Green color in RGBA space as integer
2796   // probably wrong for big-endian CPUs
2797   Standard_Integer aRed    = 0;
2798   Standard_Integer aGreen  = 255;
2799   Standard_Integer aBlue   = 0;
2800   Standard_Integer anAlpha = 0; // not used
2801   Standard_Integer aColorInt = aRed;
2802   aColorInt += aGreen  << 8;
2803   aColorInt += aBlue   << 16;
2804   aColorInt += anAlpha << 24;
2805
2806   // setup colors array per vertex
2807   Handle(TColStd_HArray1OfInteger) aColorArray = new TColStd_HArray1OfInteger (1, aNumberPoints);
2808   for (Standard_Integer aNodeId = 1; aNodeId <= aNumberPoints; ++aNodeId)
2809   {
2810     aColorArray->SetValue (aNodeId, aColorInt);
2811   }
2812   aShape->SetColors (aColorArray);
2813
2814   // show statistics
2815   Standard_Integer aPointsSize      = aNumberPoints * 3 * sizeof(float);  // 3x GLfloat
2816   Standard_Integer aNormalsSize     = aNumberPoints * 3 * sizeof(float);  // 3x GLfloat
2817   Standard_Integer aColorsSize      = aNumberPoints * 3 * sizeof(float);  // 3x GLfloat without alpha
2818   Standard_Integer aTrianglesSize   = aNumberTriangles * 3 * sizeof(int); // 3x GLint
2819   Standard_Integer aPolyConnectSize = aNumberPoints * 4 + aNumberTriangles * 6 * 4;
2820   Standard_Integer aTotalSize       = aPointsSize + aNormalsSize + aColorsSize + aTrianglesSize;
2821   aTotalSize >>= 20; //MB
2822   aNormalsSize >>= 20;
2823   aColorsSize >>= 20;
2824   aTrianglesSize >>= 20;
2825   aPolyConnectSize >>= 20;
2826   std::cout << "NumberOfPoints:    " << aNumberPoints << "\n"
2827             << "NumberOfTriangles: " << aNumberTriangles << "\n"
2828             << "Amount of memory required for PolyTriangulation without Normals: " << (aTotalSize - aNormalsSize) << " Mb\n"
2829             << "Amount of memory for colors: " << aColorsSize << " Mb\n"
2830             << "Amount of memory for PolyConnect: " << aPolyConnectSize << " Mb\n"
2831             << "Amount of graphic card memory required: " << aTotalSize << " Mb\n";
2832
2833   // Setting material properties, very important for desirable visual result!
2834   Graphic3d_MaterialAspect aMat (Graphic3d_NOM_PLASTIC);
2835   aMat.SetAmbient (0.2);
2836   aMat.SetSpecular (0.5);
2837   Handle(Graphic3d_AspectFillArea3d) anAspect
2838     = new Graphic3d_AspectFillArea3d (Aspect_IS_SOLID,
2839                                       Quantity_NOC_RED,
2840                                       Quantity_NOC_YELLOW,
2841                                       Aspect_TOL_SOLID,
2842                                       1.0,
2843                                       aMat,
2844                                       aMat);
2845   Handle(Prs3d_ShadingAspect) aShAsp = new Prs3d_ShadingAspect();
2846   if (toShowEdges)
2847   {
2848     anAspect->SetEdgeOn();
2849   }
2850   else
2851   {
2852     anAspect->SetEdgeOff();
2853   }
2854   aShAsp->SetAspect (anAspect);
2855   aShape->Attributes()->SetShadingAspect (aShAsp);
2856
2857   VDisplayAISObject (aShapeName, aShape);
2858   return 0;
2859 }
2860
2861 //===============================================================================================
2862 //function : VClipPlane
2863 //purpose  :
2864 //===============================================================================================
2865 static int VClipPlane (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
2866 {
2867   Handle(V3d_Viewer) aViewer = ViewerTest::GetViewerFromContext();
2868   Handle(V3d_View) aView = ViewerTest::CurrentView();
2869   Standard_Real coeffA, coeffB, coeffC, coeffD;
2870   if (aViewer.IsNull() || aView.IsNull())
2871   {
2872     std::cout << "Viewer not initialized!\n";
2873     return 1;
2874   }
2875
2876   // count an active planes count
2877   Standard_Integer aNewPlaneId = 1;
2878   Standard_Integer anActivePlanes = 0;
2879   for (aViewer->InitDefinedPlanes(); aViewer->MoreDefinedPlanes(); aViewer->NextDefinedPlanes(), ++aNewPlaneId)
2880   {
2881     Handle(V3d_Plane) aPlaneV3d = aViewer->DefinedPlane();
2882     if (aView->IsActivePlane (aPlaneV3d))
2883     {
2884       ++anActivePlanes;
2885     }
2886   }
2887
2888   if (argc == 1)
2889   {
2890     // just show info about existing planes
2891     Standard_Integer aPlaneId = 1;
2892     std::cout << "Active planes: " << anActivePlanes << " from maximal " << aView->View()->PlaneLimit() << "\n";
2893     for (aViewer->InitDefinedPlanes(); aViewer->MoreDefinedPlanes(); aViewer->NextDefinedPlanes(), ++aPlaneId)
2894     {
2895       Handle(V3d_Plane) aPlaneV3d = aViewer->DefinedPlane();
2896       aPlaneV3d->Plane (coeffA, coeffB, coeffC, coeffD);
2897       gp_Pln aPlane (coeffA, coeffB, coeffC, coeffD);
2898       const gp_Pnt& aLoc = aPlane.Location();
2899       const gp_Dir& aNor = aPlane.Axis().Direction();
2900       Standard_Boolean isActive = aView->IsActivePlane (aPlaneV3d);
2901       std::cout << "Plane #" << aPlaneId
2902         << " " << aLoc.X() << " " << aLoc.Y() << " " << aLoc.Z()
2903         << " " << aNor.X() << " " << aNor.Y() << " " << aNor.Z()
2904         << (isActive ? " on" : " off")
2905         << (aPlaneV3d->IsDisplayed() ? ", displayed" : ", hidden")
2906         << "\n";
2907     }
2908     if (aPlaneId == 1)
2909     {
2910       std::cout << "No defined clipping planes\n";
2911     }
2912     return 0;
2913   }
2914   else if (argc == 2 || argc == 3)
2915   {
2916     Standard_Integer aPlaneIdToOff = (argc == 3) ? atoi (argv[1]) : 1;
2917     Standard_Boolean toIterateAll = (argc == 2);
2918     TCollection_AsciiString isOnOffStr ((argc == 3) ? argv[2] : argv[1]);
2919     isOnOffStr.LowerCase();
2920     Standard_Integer aPlaneId = 1;
2921     for (aViewer->InitDefinedPlanes(); aViewer->MoreDefinedPlanes(); aViewer->NextDefinedPlanes(), ++aPlaneId)
2922     {
2923       if (aPlaneIdToOff == aPlaneId || toIterateAll)
2924       {
2925         Handle(V3d_Plane) aPlaneV3d = aViewer->DefinedPlane();
2926         if (isOnOffStr.Search ("off") >= 0)
2927         {
2928           aView->SetPlaneOff (aPlaneV3d);
2929           std::cout << "Clipping plane #" << aPlaneId << " was disabled\n";
2930         }
2931         else if (isOnOffStr.Search ("on") >= 0)
2932         {
2933           // avoid z-fighting glitches
2934           aPlaneV3d->Erase();
2935           if (!aView->IsActivePlane (aPlaneV3d))
2936           {
2937             if (anActivePlanes < aView->View()->PlaneLimit())
2938             {
2939               aView->SetPlaneOn (aPlaneV3d);
2940               std::cout << "Clipping plane #" << aPlaneId << " was enabled\n";
2941             }
2942             else
2943             {
2944               std::cout << "Maximal active planes limit exceeded (" << anActivePlanes << ")\n"
2945                         << "You should disable or remove some existing plane to activate this one\n";
2946             }
2947           }
2948           else
2949           {
2950             std::cout << "Clipping plane #" << aPlaneId << " was already enabled\n";
2951           }
2952         }
2953         else if (isOnOffStr.Search ("del") >= 0 || isOnOffStr.Search ("rem") >= 0)
2954         {
2955           aPlaneV3d->Erase(); // not performed on destructor!!!
2956           aView->SetPlaneOff (aPlaneV3d);
2957           aViewer->DelPlane (aPlaneV3d);
2958           std::cout << "Clipping plane #" << aPlaneId << " was removed\n";
2959           if (toIterateAll)
2960           {
2961             for (aViewer->InitDefinedPlanes(); aViewer->MoreDefinedPlanes(); aViewer->InitDefinedPlanes(), ++aPlaneId)
2962             {
2963               aPlaneV3d = aViewer->DefinedPlane();
2964               aPlaneV3d->Erase(); // not performed on destructor!!!
2965               aView->SetPlaneOff (aPlaneV3d);
2966               aViewer->DelPlane (aPlaneV3d);
2967               std::cout << "Clipping plane #" << aPlaneId << " was removed\n";
2968             }
2969             break;
2970           }
2971           else
2972           {
2973             break;
2974           }
2975         }
2976         else if (isOnOffStr.Search ("disp") >= 0 || isOnOffStr.Search ("show") >= 0)
2977         {
2978           // avoid z-fighting glitches
2979           aView->SetPlaneOff (aPlaneV3d);
2980           aPlaneV3d->Display (aView);
2981           std::cout << "Clipping plane #" << aPlaneId << " was shown and disabled\n";
2982         }
2983         else if (isOnOffStr.Search ("hide") >= 0)
2984         {
2985           aPlaneV3d->Erase();
2986           std::cout << "Clipping plane #" << aPlaneId << " was hidden\n";
2987         }
2988         else
2989         {
2990           std::cout << "Usage: " << argv[0] << " [x y z dx dy dz] [planeId {on/off/del/display/hide}]\n";
2991           return 1;
2992         }
2993       }
2994     }
2995     if (aPlaneIdToOff >= aPlaneId && !toIterateAll)
2996     {
2997       std::cout << "Clipping plane with id " << aPlaneIdToOff << " not found!\n";
2998       return 1;
2999     }
3000     aView->Update();
3001     return 0;
3002   }
3003   else if (argc != 7)
3004   {
3005     std::cout << "Usage: " << argv[0] << " [x y z dx dy dz] [planeId {on/off/del/display/hide}]\n";
3006     return 1;
3007   }
3008
3009   Standard_Real aLocX = atof (argv[1]);
3010   Standard_Real aLocY = atof (argv[2]);
3011   Standard_Real aLocZ = atof (argv[3]);
3012   Standard_Real aNormDX = atof (argv[4]);
3013   Standard_Real aNormDY = atof (argv[5]);
3014   Standard_Real aNormDZ = atof (argv[6]);
3015
3016   Handle(V3d_Plane) aPlaneV3d = new V3d_Plane();
3017   gp_Pln aPlane (gp_Pnt (aLocX, aLocY, aLocZ), gp_Dir (aNormDX, aNormDY, aNormDZ));
3018   aPlane.Coefficients (coeffA, coeffB, coeffC, coeffD);
3019   aPlaneV3d->SetPlane(coeffA, coeffB, coeffC, coeffD);
3020
3021   aViewer->AddPlane (aPlaneV3d); // add to defined planes list
3022   std::cout << "Added clipping plane #" << aNewPlaneId << "\n";
3023   if (anActivePlanes < aView->View()->PlaneLimit())
3024   {
3025     aView->SetPlaneOn (aPlaneV3d); // add to enabled planes list
3026     aView->Update();
3027   }
3028   else
3029   {
3030     std::cout << "Maximal active planes limit exceeded (" << anActivePlanes << ")\n"
3031               << "You should disable or remove some existing plane to activate the new one\n";
3032   }
3033   return 0;
3034 }
3035
3036 //=============================================================================
3037 //function : VComputeHLR
3038 //purpose  :
3039 //=============================================================================
3040
3041 static int VComputeHLR (Draw_Interpretor& di,
3042                         Standard_Integer argc,
3043                         const char** argv)
3044 {
3045   Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext ();
3046
3047   if (aContextAIS.IsNull ())
3048   {
3049     di << "Please call vinit before\n";
3050     return 1;
3051   }
3052
3053   if ( argc != 3 &&  argc != 12 )
3054   {
3055     di << "Usage: " << argv[0] << " ShapeName HlrName "
3056        << "[ eye_x eye_y eye_z dir_x dir_y dir_z upx upy upz ]" << "\n"
3057        << "                    ShapeName - name of the initial shape\n"
3058        << "                    HlrName - result hlr object from initial shape\n"
3059        << "                    eye, dir are eye position and look direction\n"
3060        << "                    up is the look up direction vector\n"
3061        << "                    Use vtop to see projected hlr shape\n";
3062     return 1;
3063   }
3064
3065   // shape and new object name
3066   TCollection_AsciiString aShapeName (argv[1]);
3067   TCollection_AsciiString aHlrName (argv[2]);
3068
3069   TopoDS_Shape aSh = DBRep::Get (argv[1]);
3070   if (aSh.IsNull())
3071   {
3072     BRep_Builder aBrepBuilder;
3073     BRepTools::Read (aSh, argv[1], aBrepBuilder);
3074     if (aSh.IsNull ())
3075     {
3076       di << "No shape with name " << argv[1] << " found\n";
3077       return 1;
3078     }
3079   }
3080
3081   if (GetMapOfAIS ().IsBound2 (aHlrName))
3082   {
3083     di << "Presentable object with name " << argv[2] << " already exists\n";
3084     return 1;
3085   }
3086
3087   // close local context
3088   if (aContextAIS->HasOpenedContext ())
3089     aContextAIS->CloseLocalContext ();
3090
3091   Handle(HLRBRep_PolyAlgo) aPolyAlgo = new HLRBRep_PolyAlgo();
3092   HLRBRep_PolyHLRToShape aHLRToShape;
3093
3094   gp_Pnt anEye;
3095   gp_Dir aDir;
3096   gp_Ax2 aProjAx;
3097   if (argc == 9)
3098   {
3099     gp_Dir anUp;
3100
3101     anEye.SetCoord (atof (argv[3]), atof (argv[4]), atof (argv[5]));
3102     aDir.SetCoord (atof (argv[6]), atof (argv[7]), atof (argv[8]));
3103     anUp.SetCoord (atof (argv[9]), atof (argv[10]), atof (argv[11]));
3104     aProjAx.SetLocation (anEye);
3105     aProjAx.SetDirection (aDir);
3106     aProjAx.SetYDirection (anUp);
3107   }
3108   else
3109   {
3110     gp_Dir aRight;
3111
3112     Handle(V3d_Viewer) aViewer = ViewerTest::GetViewerFromContext();
3113     Handle(V3d_View)   aView   = ViewerTest::CurrentView();
3114     Standard_Integer aWidth, aHeight;
3115     Standard_Real aCentX, aCentY, aCentZ, aDirX, aDirY, aDirZ;
3116     Standard_Real aRightX, aRightY, aRightZ;
3117     aView->Window()->Size (aWidth, aHeight);
3118
3119     aView->ConvertWithProj (aWidth, aHeight/2,
3120                             aRightX, aRightY, aRightZ,
3121                             aDirX, aDirY, aDirZ);
3122
3123     aView->ConvertWithProj (aWidth/2, aHeight/2,
3124                             aCentX, aCentY, aCentZ,
3125                             aDirX, aDirY, aDirZ);
3126
3127     anEye.SetCoord (-aCentX, -aCentY, -aCentZ);
3128     aDir.SetCoord (-aDirX, -aDirY, -aDirZ);
3129     aRight.SetCoord (aRightX - aCentX, aRightY - aCentY, aRightZ - aCentZ);
3130     aProjAx.SetLocation (anEye);
3131     aProjAx.SetDirection (aDir);
3132     aProjAx.SetXDirection (aRight);
3133   }
3134
3135   HLRAlgo_Projector aProjector (aProjAx);
3136   aPolyAlgo->Projector (aProjector);
3137   aPolyAlgo->Load (aSh);
3138   aPolyAlgo->Update ();
3139
3140   aHLRToShape.Update (aPolyAlgo);
3141
3142   // make hlr shape from input shape
3143   TopoDS_Compound aHlrShape;
3144   BRep_Builder aBuilder;
3145   aBuilder.MakeCompound (aHlrShape);
3146
3147   TopoDS_Shape aCompound = aHLRToShape.VCompound();
3148   if (!aCompound.IsNull ())
3149   {
3150     aBuilder.Add (aHlrShape, aCompound);
3151   }
3152
3153   // extract visible outlines
3154   aCompound = aHLRToShape.OutLineVCompound();
3155   if (!aCompound.IsNull ())
3156   {
3157     aBuilder.Add (aHlrShape, aCompound);
3158   }
3159
3160   // create an AIS shape and display it
3161   Handle(AIS_Shape) anObject = new AIS_Shape (aHlrShape);
3162   GetMapOfAIS().Bind (anObject, aHlrName);
3163   aContextAIS->Display (anObject);
3164
3165   aContextAIS->UpdateCurrentViewer ();
3166
3167   return 0;
3168 }
3169
3170 // This class is a wrap for Graphic3d_ArrayOfPrimitives; it is used for
3171 // manipulating and displaying such an array with AIS context
3172 DEFINE_STANDARD_HANDLE(MyPArrayObject, AIS_InteractiveObject)
3173 class MyPArrayObject : public AIS_InteractiveObject
3174 {
3175
3176 public:
3177
3178   MyPArrayObject (const Handle(Graphic3d_ArrayOfPrimitives) theArray)
3179   {
3180     myArray = theArray;
3181   }
3182
3183   DEFINE_STANDARD_RTTI(MyPArrayObject);
3184
3185 private:
3186
3187   void Compute (const Handle(PrsMgr_PresentationManager3d)& aPresentationManager,
3188                 const Handle(Prs3d_Presentation)& aPresentation,
3189                 const Standard_Integer aMode);
3190
3191   void ComputeSelection (const Handle(SelectMgr_Selection)& aSelection,
3192                          const Standard_Integer aMode) {};
3193
3194 protected:
3195
3196   Handle(Graphic3d_ArrayOfPrimitives) myArray;
3197
3198 };
3199
3200 IMPLEMENT_STANDARD_HANDLE(MyPArrayObject, AIS_InteractiveObject)
3201 IMPLEMENT_STANDARD_RTTIEXT(MyPArrayObject, AIS_InteractiveObject)
3202
3203 void MyPArrayObject::Compute (const Handle(PrsMgr_PresentationManager3d)& aPresentationManager,
3204                               const Handle(Prs3d_Presentation)& aPresentation,
3205                               const Standard_Integer aMode)
3206 {
3207   aPresentation->Clear();
3208
3209   Handle (Graphic3d_Group) aGroup = Prs3d_Root::CurrentGroup (aPresentation);
3210   aGroup->BeginPrimitives ();
3211   aGroup->AddPrimitiveArray (myArray);
3212   aGroup->EndPrimitives ();
3213 }
3214
3215 static bool CheckInputCommand (const TCollection_AsciiString theCommand,
3216                                const char **theArgStr, int &theArgIndex,
3217                                int theArgCount, int theMaxArgs)
3218 {
3219   // check if there is more elements than expected
3220   if (theArgIndex >= theMaxArgs)
3221     return false;
3222
3223   TCollection_AsciiString aStrCommand(theArgStr[theArgIndex]);
3224   aStrCommand.LowerCase();
3225   if (aStrCommand.Search(theCommand) != 1 ||
3226       theArgIndex + (theArgCount - 1) >= theMaxArgs)
3227     return false;
3228
3229   // go to the first data element
3230   theArgIndex++;
3231
3232   // check data if it can be converted to numeric
3233   for (int aElement = 0; aElement < theArgCount; aElement++, theArgIndex++)
3234   {
3235     aStrCommand = theArgStr[theArgIndex];
3236     if (!aStrCommand.IsRealValue())
3237       return false;
3238   }
3239
3240   return true;
3241 }
3242
3243 //=============================================================================
3244 //function : VDrawPArray
3245 //purpose  : Draws primitives array from list of vertexes, bounds, edges
3246 //=============================================================================
3247
3248 static int VDrawPArray (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
3249 {
3250   Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext();
3251   if (aContextAIS.IsNull())
3252   {
3253     di << "Call vinit before!\n";
3254     return 1;
3255   }
3256   else if (argc < 3)
3257   {
3258     di << "Use: " << argv[0] << " Name TypeOfArray"
3259        << " [vertex] ... [bounds] ... [edges]\n"
3260        << "  TypeOfArray={ points | segments | polylines | triangles |\n"
3261        << "                trianglefans | trianglestrips | quads |\n"
3262        << "                quadstrips | polygons }\n"
3263        << "  vertex={ 'v' x y z [normal={ 'n' nx ny nz }] [color={ 'c' r g b }]"
3264        << " [texel={ 't' tx ty }] } \n"
3265        << "  bounds={ 'b' verticies_count [color={ 'c' r g b }] }\n"
3266        << "  edges={ 'e' vertex_id [hidden_edge={'h'}] }\n";
3267     return 1;
3268   }
3269
3270   // read the arguments
3271   Standard_Integer aArgIndex = 1;
3272   TCollection_AsciiString aName (argv[aArgIndex++]);
3273   TCollection_AsciiString anArrayType (argv[aArgIndex++]);
3274   const Standard_Integer anArgsFrom = aArgIndex;
3275
3276   // parse number of verticies, bounds, edges
3277   Standard_Integer aVertexNum = 0, aBoundNum = 0, aEdgeNum = 0;
3278   Standard_Boolean hasVColors, hasBColors, hasNormals, hasInfos, hasTexels;
3279   hasVColors = hasNormals = hasBColors = hasInfos = hasTexels = Standard_False;
3280
3281   TCollection_AsciiString aCommand;
3282   while (aArgIndex < argc)
3283   {
3284     aCommand = argv[aArgIndex];
3285     aCommand.LowerCase();
3286     if (!aCommand.IsAscii())
3287     {
3288       di << "Unexpected argument: #" << aArgIndex - 1 << " , "
3289          << "should be an array element: 'v', 'b', 'e' \n";
3290       break;
3291     }
3292
3293     // vertex command
3294     if (CheckInputCommand ("v", argv, aArgIndex, 3, argc))
3295     {
3296       // vertex has a normal or normal with color or texel
3297       if (CheckInputCommand ("n", argv, aArgIndex, 3, argc))
3298         hasNormals = Standard_True;
3299
3300       // vertex has a color
3301       if (CheckInputCommand ("c", argv, aArgIndex, 3, argc))
3302         hasVColors = Standard_True;
3303
3304       // vertex has a texel
3305       if (CheckInputCommand ("t", argv, aArgIndex, 2, argc))
3306         hasTexels = Standard_True;
3307
3308       aVertexNum++;
3309     }
3310     // bound command
3311     else if (CheckInputCommand ("b", argv, aArgIndex, 1, argc))
3312     {
3313       // bound has color
3314       if (CheckInputCommand ("c", argv, aArgIndex, 3, argc))
3315         hasBColors = Standard_True;
3316
3317       aBoundNum++;
3318     }
3319     // edge command
3320     else if (CheckInputCommand ("e", argv, aArgIndex, 1, argc))
3321     {
3322       // edge has a hide flag
3323       if (CheckInputCommand ("h", argv, aArgIndex, 0, argc))
3324         hasInfos = Standard_True;
3325
3326       aEdgeNum++;
3327     }
3328     // unknown command
3329     else
3330       aArgIndex++;
3331   }
3332
3333   if (aVertexNum == 0)
3334   {
3335     di << "You should pass any verticies in the list of array elements\n";
3336     return 1;
3337   }
3338
3339   // create an array of primitives by types
3340   Handle(Graphic3d_ArrayOfPrimitives) anArray;
3341   if (anArrayType == "points")
3342     anArray = new Graphic3d_ArrayOfPoints (aVertexNum);
3343   else if (anArrayType == "segments")
3344     anArray = new Graphic3d_ArrayOfSegments (aVertexNum, aEdgeNum, hasVColors);
3345   else if (anArrayType == "polylines")
3346     anArray = new Graphic3d_ArrayOfPolylines (aVertexNum, aBoundNum, aEdgeNum,
3347                                               hasVColors, hasBColors, hasInfos);
3348   else if (anArrayType == "triangles")
3349     anArray = new Graphic3d_ArrayOfTriangles (aVertexNum, aEdgeNum, hasNormals,
3350                                               hasVColors, hasTexels, hasInfos);
3351   else if (anArrayType == "trianglefans")
3352     anArray = new Graphic3d_ArrayOfTriangleFans (aVertexNum, aBoundNum,
3353                                                  hasNormals, hasVColors,
3354                                                  hasBColors, hasTexels);
3355   else if (anArrayType == "trianglestrips")
3356     anArray = new Graphic3d_ArrayOfTriangleStrips (aVertexNum, aBoundNum,
3357                                                    hasNormals, hasVColors,
3358                                                    hasBColors, hasTexels);
3359   else if (anArrayType == "quads")
3360     anArray = new Graphic3d_ArrayOfQuadrangles (aVertexNum, aEdgeNum,
3361                                                 hasNormals, hasVColors,
3362                                                 hasTexels, hasInfos);
3363   else if (anArrayType == "quadstrips")
3364     anArray = new Graphic3d_ArrayOfQuadrangleStrips (aVertexNum, aBoundNum,
3365                                                      hasNormals, hasVColors,
3366                                                      hasBColors, hasTexels);
3367   else if (anArrayType == "polygons")
3368     anArray = new Graphic3d_ArrayOfPolygons (aVertexNum, aBoundNum, aEdgeNum,
3369                                              hasNormals, hasVColors, hasBColors,
3370                                              hasTexels, hasInfos);
3371   else
3372   {
3373     di << "Unexpected type of primitiives array\n";
3374     return 1;
3375   }
3376
3377   // parse an array of primitives
3378   aArgIndex = anArgsFrom;
3379   while (aArgIndex < argc)
3380   {
3381     aCommand = argv[aArgIndex];
3382     aCommand.LowerCase();
3383     if (!aCommand.IsAscii())
3384       break;
3385
3386     // vertex command
3387     if (CheckInputCommand ("v", argv, aArgIndex, 3, argc))
3388     {
3389       anArray->AddVertex (atof (argv[aArgIndex - 3]),
3390                           atof (argv[aArgIndex - 2]),
3391                           atof (argv[aArgIndex - 1]));
3392
3393       // vertex has a normal or normal with color or texel
3394       if (CheckInputCommand ("n", argv, aArgIndex, 3, argc))
3395         anArray->SetVertexNormal (anArray->VertexNumber (),
3396                                   atof (argv[aArgIndex - 3]),
3397                                   atof (argv[aArgIndex - 2]),
3398                                   atof (argv[aArgIndex - 1]));
3399
3400       if (CheckInputCommand ("c", argv, aArgIndex, 3, argc))
3401         anArray->SetVertexColor (anArray->VertexNumber (),
3402                                  atof (argv[aArgIndex - 3]),
3403                                  atof (argv[aArgIndex - 2]),
3404                                  atof (argv[aArgIndex - 1]));
3405
3406       if (CheckInputCommand ("t", argv, aArgIndex, 2, argc))
3407         anArray->SetVertexTexel (anArray->VertexNumber (),
3408                                  atof (argv[aArgIndex - 2]),
3409                                  atof (argv[aArgIndex - 1]));
3410     }
3411     // bounds command
3412     else if (CheckInputCommand ("b", argv, aArgIndex, 1, argc))
3413     {
3414       Standard_Integer aVertCount = atoi (argv[aArgIndex - 1]);
3415
3416       if (CheckInputCommand ("c", argv, aArgIndex, 3, argc))
3417         anArray->AddBound (aVertCount,
3418                            atof (argv[aArgIndex - 3]),
3419                            atof (argv[aArgIndex - 2]),
3420                            atof (argv[aArgIndex - 1]));
3421
3422       else
3423         anArray->AddBound (aVertCount);
3424     }
3425     // edge command
3426     else if (CheckInputCommand ("e", argv, aArgIndex, 1, argc))
3427     {
3428       Standard_Integer aVertIndex = atoi (argv[aArgIndex - 1]);
3429
3430       // edge has/hasn't hide flag
3431       if (CheckInputCommand ("h", argv, aArgIndex, 0, argc))
3432         anArray->AddEdge (aVertIndex, Standard_False);
3433       else
3434         anArray->AddEdge (aVertIndex, Standard_True);
3435     }
3436     // unknown command
3437     else
3438       aArgIndex++;
3439   }
3440
3441   // create primitives array object
3442   Handle (MyPArrayObject) aPObject = new MyPArrayObject (anArray);
3443
3444   // register the object in map
3445   VDisplayAISObject (aName, aPObject);
3446
3447   return 0;
3448 }
3449
3450 //=======================================================================
3451 //function : VSetLocation
3452 //purpose  : Change location of AIS interactive object
3453 //=======================================================================
3454
3455 static Standard_Integer VSetLocation (Draw_Interpretor& di,
3456                                       Standard_Integer argc,
3457                                       const char ** argv)
3458 {
3459   Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
3460   if (aContext.IsNull())
3461   {
3462     di << argv[0] << "ERROR : use 'vinit' command before " << "\n";
3463     return 1;
3464   }
3465
3466   if (argc != 5)
3467   {
3468     di << "ERROR : Usage : " << argv[0] << " name x y z; new location" << "\n";
3469     return 1;
3470   }
3471
3472   TCollection_AsciiString aName (argv[1]);
3473   Standard_Real aX = atof (argv[2]);
3474   Standard_Real aY = atof (argv[3]);
3475   Standard_Real aZ = atof (argv[4]);
3476
3477   // find object
3478   ViewerTest_DoubleMapOfInteractiveAndName& aMap = GetMapOfAIS();
3479   Handle(AIS_InteractiveObject) anIObj;
3480   if (!aMap.IsBound2 (aName))
3481   {
3482     di << "Use 'vdisplay' before" << "\n";
3483     return 1;
3484   }
3485   else
3486   {
3487     anIObj = Handle(AIS_InteractiveObject)::DownCast (aMap.Find2 (aName));
3488
3489     // not an AIS_InteractiveObject
3490     if (anIObj.IsNull())
3491     {
3492       di << argv[1] << " : Not an AIS interactive object" << "\n";
3493       return 1;
3494     }
3495
3496     gp_Trsf aTrsf;
3497     aTrsf.SetTranslation (gp_Vec (aX, aY, aZ));
3498     TopLoc_Location aLocation (aTrsf);
3499     aContext->SetLocation (anIObj, aLocation);
3500     aContext->UpdateCurrentViewer();
3501   }
3502
3503   return 0;
3504 }
3505
3506 //===============================================================================================
3507 //function : VConnect
3508 //purpose  : Creates and displays AIS_ConnectedInteractive object from input object and location
3509 //Draw arg : vconnect name Xo Yo Zo Xu Xv Xw Zu Zv Zw object1 object2 ... [color=NAME]
3510 //===============================================================================================
3511
3512 static Standard_Integer VConnect(Draw_Interpretor& di,
3513                                  Standard_Integer argc,
3514                                  const char ** argv)
3515 {
3516   // Check the viewer
3517   Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
3518   if (aContext.IsNull())
3519   {
3520     std::cout << "vconnect error : call vinit before\n";
3521     return 1; // TCL_ERROR
3522   }
3523   // Check argumnets
3524   if (argc < 12)
3525   {
3526     std::cout << "vconnect error: expect at least 11 arguments\n";
3527     return 1; // TCL_ERROR
3528   }
3529
3530   // Get values
3531   Standard_Integer anArgIter = 1;
3532   TCollection_AsciiString aName (argv[anArgIter++]);
3533   Handle(AIS_InteractiveObject) anOriginObject;
3534   TCollection_AsciiString aColorString (argv[argc-1]);
3535   Standard_CString aColorName;
3536   Standard_Boolean hasColor = Standard_False;
3537   if (aColorString.Search ("color=") != -1)
3538   {
3539     hasColor = Standard_True;
3540     aColorString.Remove (1, 6);
3541     aColorName = aColorString.ToCString();
3542   }
3543   Handle(AIS_InteractiveObject) anObject;
3544
3545   // AIS_ConnectedInteractive
3546   if (argc == 12 || (argc == 13 && hasColor))
3547   {
3548     TCollection_AsciiString anOriginObjectName(argv[11]);
3549     if (aName.IsEqual (anOriginObjectName))
3550     {
3551       std::cout << "vconnect error: equal names for connected objects\n";
3552       return 1; // TCL_ERROR
3553     }
3554     if (GetMapOfAIS().IsBound2 (anOriginObjectName))
3555     {
3556       Handle(Standard_Transient) anObj = GetMapOfAIS().Find2 (anOriginObjectName);
3557       anOriginObject = Handle(AIS_InteractiveObject)::DownCast(anObj);
3558       if (anOriginObject.IsNull())
3559       {
3560         std::cout << "Object " << anOriginObjectName << " is used for non AIS viewer\n";
3561         return 1; // TCL_ERROR
3562       }
3563     }
3564     else
3565     {
3566       Standard_CString aName = anOriginObjectName.ToCString();
3567       TopoDS_Shape aTDShape = DBRep::Get (aName);
3568       if (aTDShape.IsNull())
3569       {
3570         std::cout << "vconnect error: object " << anOriginObjectName << " doesn't exist\n";
3571         return 1; // TCL_ERROR
3572       }
3573       anOriginObject = new AIS_Shape (aTDShape);
3574       if (hasColor)
3575       {
3576         anOriginObject->SetColor (ViewerTest::GetColorFromName (aColorName));
3577       }
3578     }
3579   }
3580   // AIS_MultipleConnectedInteractive
3581   else
3582   {
3583     const Standard_Integer aNbShapes = hasColor ? (argc - 1) : argc;
3584     for (Standard_Integer i = 11; i < aNbShapes; ++i)
3585     {
3586       TCollection_AsciiString anOriginObjectName (argv[i]);
3587       if (aName.IsEqual (anOriginObjectName))
3588       {
3589         std::cout << "vconnect error: equal names for connected objects\n";
3590         continue;
3591       }
3592       if (GetMapOfAIS().IsBound2 (anOriginObjectName))
3593       {
3594         Handle(Standard_Transient) anObj = GetMapOfAIS().Find2 (anOriginObjectName);
3595         anObject = Handle(AIS_InteractiveObject)::DownCast(anObj);
3596         if (anObject.IsNull())
3597         {
3598           std::cout << "Object " << anOriginObjectName << " is used for non AIS viewer\n";
3599           continue;
3600         }
3601       }
3602       else
3603       {
3604         Standard_CString aName = anOriginObjectName.ToCString();
3605         TopoDS_Shape aTDShape = DBRep::Get (aName);
3606         if (aTDShape.IsNull())
3607         {
3608           std::cout << "vconnect error: object " << anOriginObjectName << " doesn't exist\n";
3609           continue;
3610         }
3611         anObject = new AIS_Shape (aTDShape);
3612         anObject->SetColor (ViewerTest::GetColorFromName (aColorName));
3613       }
3614       if (anOriginObject.IsNull())
3615       {
3616         anOriginObject = new AIS_MultipleConnectedInteractive();
3617         Handle(AIS_MultipleConnectedInteractive)::DownCast(anOriginObject)->Connect (anObject);
3618       }
3619       else
3620       {
3621         Handle(AIS_MultipleConnectedInteractive)::DownCast(anOriginObject)->Connect (anObject);
3622       }
3623     }
3624     if (anOriginObject.IsNull())
3625     {
3626       std::cout << "vconect error : can't connect input objects\n";
3627       return 1; // TCL_ERROR
3628     }
3629   }
3630
3631   // Get location data
3632   Standard_Real aXo = atof (argv[anArgIter++]);
3633   Standard_Real aYo = atof (argv[anArgIter++]);
3634   Standard_Real aZo = atof (argv[anArgIter++]);
3635   Standard_Real aXu = atof (argv[anArgIter++]);
3636   Standard_Real aXv = atof (argv[anArgIter++]);
3637   Standard_Real aXw = atof (argv[anArgIter++]);
3638   Standard_Real aZu = atof (argv[anArgIter++]);
3639   Standard_Real aZv = atof (argv[anArgIter++]);
3640   Standard_Real aZw = atof (argv[anArgIter++]);
3641
3642   // Create transformation
3643   gp_Pnt aPoint(aXo, aYo, aZo);
3644   gp_Dir anXDir(aXu, aXv, aXw), aZDir(aZu, aZv, aZw);
3645   if(!anXDir.IsNormal(aZDir, Precision::Angular()))
3646   {
3647     std::cout << "vconnect error : XDir expects to be normal to ZDir\n";
3648     return 1; // TCL_ERROR
3649   }
3650   gp_Ax3 anAx3(aPoint, aZDir, anXDir);
3651   gp_Trsf aTrsf;
3652   aTrsf.SetTransformation(anAx3);
3653   TopLoc_Location aLocation(aTrsf);
3654
3655   // Create connected object
3656   Handle(AIS_ConnectedInteractive) aConnected = new AIS_ConnectedInteractive();
3657   Handle(AIS_MultipleConnectedInteractive) anOrigin = Handle(AIS_MultipleConnectedInteractive)::DownCast(anOriginObject);
3658   if (anOrigin.IsNull())
3659   {
3660     aConnected->Connect (anOriginObject, aLocation);
3661   }
3662   else
3663   {
3664     aConnected->Connect (anOrigin, aLocation);
3665   }
3666
3667   // Check if there is another object with given name
3668   // and remove it from context
3669   if(GetMapOfAIS().IsBound2(aName))
3670   {
3671     Handle(AIS_InteractiveObject) anObj =
3672       Handle(AIS_InteractiveObject)::DownCast(GetMapOfAIS().Find2(aName));
3673     TheAISContext()->Remove(anObj, Standard_False);
3674     GetMapOfAIS().UnBind2(aName);
3675   }
3676
3677   // Bind connected object to its name
3678   GetMapOfAIS().Bind (aConnected, aName);
3679
3680   // Display connected object
3681   TheAISContext()->Display (aConnected);
3682
3683   return 0;
3684 }
3685
3686 //===============================================================================================
3687 //function : VConnectShape
3688 //purpose  : Creates and displays AIS_ConnectedShape from input shape and location
3689 //Draw arg : vconnectsh name Xo Yo Zo Xu Xv Xw Zu Zv Zw shape1 shape2 ... [color=NAME]
3690 //===============================================================================================
3691
3692 static Standard_Integer VConnectShape(Draw_Interpretor& di,
3693                                       Standard_Integer argc,
3694                                       const char ** argv)
3695 {
3696   // Check the viewer
3697   Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
3698   if (aContext.IsNull())
3699   {
3700     std::cout << "vconnectsh error : call vinit before\n";
3701     return 1; // TCL_ERROR
3702   }
3703   // Check argumnets
3704   if (argc < 12)
3705   {
3706     std::cout << "vconnectsh error: expect at least 11 arguments\n";
3707     return 1; // TCL_ERROR
3708   }
3709
3710   // Get values
3711   Standard_Integer anArgIter = 1;
3712   TCollection_AsciiString aName (argv[anArgIter++]);
3713   Handle(AIS_InteractiveObject) anOriginShape;
3714   TCollection_AsciiString aColorString(argv[argc-1]);
3715   Standard_CString aColorName;
3716   Standard_Boolean hasColor = Standard_False;
3717   if (aColorString.Search ("color=") != -1)
3718   {
3719     hasColor = Standard_True;
3720     aColorString.Remove (1, 6);
3721     aColorName = aColorString.ToCString();
3722   }
3723   Handle(AIS_Shape) aShape;
3724
3725   // AIS_ConnectedShape
3726   if (argc == 12 || (argc == 13 && hasColor))
3727   {
3728     TCollection_AsciiString anOriginShapeName (argv[11]);
3729     if (aName.IsEqual (anOriginShapeName))
3730     {
3731       std::cout << "vconnectsh error: equal names for connected shapes\n";
3732       return 1; // TCL_ERROR
3733     }
3734     if (GetMapOfAIS().IsBound2 (anOriginShapeName))
3735     {
3736       Handle(Standard_Transient) anObj = GetMapOfAIS().Find2 (anOriginShapeName);
3737       anOriginShape = Handle(AIS_Shape)::DownCast(anObj);
3738       if (anOriginShape.IsNull())
3739       {
3740         std::cout << "Shape " << anOriginShapeName << " is used for non AIS viewer\n!";
3741         return 1; // TCL_ERROR
3742       }
3743     }
3744     else
3745     {
3746       Standard_CString aName = anOriginShapeName.ToCString();
3747       TopoDS_Shape aTDShape = DBRep::Get (aName);
3748       if (aTDShape.IsNull())
3749       {
3750         std::cout << "vconnectsh error: object " << anOriginShapeName << " doesn't exist\n";
3751         return 1; // TCL_ERROR
3752       }
3753       anOriginShape = new AIS_Shape (aTDShape);
3754       if (hasColor)
3755       {
3756         anOriginShape->SetColor (ViewerTest::GetColorFromName (aColorName));
3757       }
3758     }
3759   }
3760   // AIS_MultipleConnectedShape
3761   else
3762   {
3763     const Standard_Integer aNbShapes = hasColor ? (argc - 1) : argc;
3764     for (Standard_Integer i = 11; i < aNbShapes; ++i)
3765     {
3766       TCollection_AsciiString anOriginShapeName (argv[i]);
3767       if (aName.IsEqual (anOriginShapeName))
3768       {
3769         std::cout << "vconnectsh error: equal names for connected shapes\n";
3770         continue;
3771       }
3772       if (GetMapOfAIS().IsBound2 (anOriginShapeName))
3773       {
3774         Handle(Standard_Transient) anObj = GetMapOfAIS().Find2 (anOriginShapeName);
3775         aShape = Handle(AIS_Shape)::DownCast(anObj);
3776         if (aShape.IsNull())
3777         {
3778           std::cout << "Shape " << anOriginShapeName << " is used for non AIS viewer\n";
3779           continue;
3780         }
3781       }
3782       else
3783       {
3784         Standard_CString aName = anOriginShapeName.ToCString();
3785         TopoDS_Shape aTDShape = DBRep::Get (aName);
3786         if (aTDShape.IsNull())
3787         {
3788           std::cout << "vconnectsh error: object " << anOriginShapeName << " doesn't exist\n";
3789           continue;
3790         }
3791         aShape = new AIS_Shape (aTDShape);
3792         if (hasColor)
3793         {
3794           aShape->SetColor (ViewerTest::GetColorFromName (aColorName));
3795         }
3796       }
3797       if (anOriginShape.IsNull())
3798       {
3799         anOriginShape = new AIS_MultipleConnectedShape (aShape->Shape());
3800         Handle(AIS_MultipleConnectedShape)::DownCast(anOriginShape)->Connect (aShape);
3801       }
3802       else
3803       {
3804         Handle(AIS_MultipleConnectedShape)::DownCast(anOriginShape)->Connect (aShape);
3805       }
3806     }
3807     if (anOriginShape.IsNull())
3808     {
3809       std::cout << "vconectsh error : can't connect input objects\n";
3810       return 1; // TCL_ERROR
3811     }
3812   }
3813
3814   // Get location data
3815   Standard_Real aXo = atof (argv[anArgIter++]);
3816   Standard_Real aYo = atof (argv[anArgIter++]);
3817   Standard_Real aZo = atof (argv[anArgIter++]);
3818   Standard_Real aXu = atof (argv[anArgIter++]);
3819   Standard_Real aXv = atof (argv[anArgIter++]);
3820   Standard_Real aXw = atof (argv[anArgIter++]);
3821   Standard_Real aZu = atof (argv[anArgIter++]);
3822   Standard_Real aZv = atof (argv[anArgIter++]);
3823   Standard_Real aZw = atof (argv[anArgIter++]);
3824
3825   // Create transformation
3826   gp_Pnt aPoint(aXo, aYo, aZo);
3827   gp_Dir anXDir(aXu, aXv, aXw), aZDir(aZu, aZv, aZw);
3828   if(!anXDir.IsNormal(aZDir, Precision::Angular()))
3829   {
3830     std::cout << "vconnectsh error : XDir expects to be normal to ZDir\n";
3831     return 1; // TCL_ERROR
3832   }
3833   gp_Ax3 anAx3(aPoint, aZDir, anXDir);
3834   gp_Trsf aTrsf;
3835   aTrsf.SetTransformation(anAx3);
3836   TopLoc_Location aLocation(aTrsf);
3837
3838   // Create connected shape
3839   Handle(AIS_ConnectedInteractive) aConnected;
3840   Handle(AIS_Shape) anOrigin = Handle(AIS_Shape)::DownCast(anOriginShape);
3841   if (!anOrigin.IsNull())
3842   {
3843     aConnected = new AIS_ConnectedShape (anOrigin);
3844     aConnected->Connect (anOrigin, aLocation);
3845   }
3846   else
3847   {
3848     aConnected = new AIS_ConnectedInteractive();
3849     aConnected->Connect (anOriginShape, aLocation);
3850   }
3851
3852   // Check if there is another object with given name
3853   // and remove it from context
3854   if(GetMapOfAIS().IsBound2(aName))
3855   {
3856     Handle(AIS_InteractiveObject) anObj =
3857       Handle(AIS_InteractiveObject)::DownCast(GetMapOfAIS().Find2(aName));
3858     TheAISContext()->Remove(anObj, Standard_False);
3859     GetMapOfAIS().UnBind2(aName);
3860   }
3861
3862   // Bind connected shape to its name
3863   GetMapOfAIS().Bind (aConnected, aName);
3864
3865   // Display connected shape
3866   TheAISContext()->Display (aConnected);
3867
3868   return 0;
3869 }
3870
3871 //===============================================================================================
3872 //function : VSetSelectionMode
3873 //purpose  : Sets input selection mode for input object or for all displayed objects
3874 //Draw arg : vselmode [object] mode On/Off (1/0)
3875 //===============================================================================================
3876
3877 // function : InList
3878 // purpose  : checks if theMode is already turned on for theObj
3879 Standard_Boolean InList(Handle(AIS_InteractiveContext) theAISContext,
3880                           Handle(AIS_InteractiveObject) theObj,
3881                           Standard_Integer theMode)
3882 {
3883   TColStd_ListOfInteger anArray;
3884   theAISContext->ActivatedModes(theObj, anArray);
3885   TColStd_ListIteratorOfListOfInteger anIt(anArray);
3886   for(; anIt.More(); anIt.Next())
3887   {
3888     if(anIt.Value() == theMode)
3889       return Standard_True;
3890   }
3891   return Standard_False;
3892 }
3893
3894 static Standard_Integer VSetSelectionMode(Draw_Interpretor& di,
3895                                           Standard_Integer argc,
3896                                           const char ** argv)
3897 {
3898   // Check errors
3899   Handle(AIS_InteractiveContext) anAISContext = ViewerTest::GetAISContext();
3900   if(anAISContext.IsNull())
3901   {
3902     std::cout << "Call vinit before!\n";
3903     return 1; // TCL_ERROR
3904   }
3905
3906   // Check the arguments
3907   if(argc != 3 && argc != 4)
3908   {
3909     std::cout << "vselmode error : expects at least 2 arguments\n";
3910     return 1; // TCL_ERROR
3911   }
3912
3913   Handle(AIS_InteractiveObject) anObj;
3914
3915   // Set new selection mode for all objects in context
3916   if(argc == 3)
3917   {
3918     // Get arguments
3919     Standard_Integer aMode = atoi(argv[1]);
3920     Standard_Boolean isTurnOn = atoi(argv[2]);
3921
3922     // Get all displayed objects
3923     AIS_ListOfInteractive anObjList;
3924     anAISContext->DisplayedObjects(anObjList);
3925     AIS_ListIteratorOfListOfInteractive anObjIter;
3926
3927     if(aMode == 0)
3928     {
3929       if(anAISContext->HasOpenedContext())
3930         anAISContext->CloseLocalContext();
3931     }
3932
3933     // Turn on aMode
3934     if(aMode != 0 && isTurnOn)
3935     {
3936       if(!anAISContext->HasOpenedContext())
3937       {
3938         anAISContext->OpenLocalContext();
3939         for(anObjIter.Initialize(anObjList); anObjIter.More(); anObjIter.Next())
3940         {
3941           anAISContext->Activate(anObjIter.Value(), aMode);
3942         }
3943       }
3944       else
3945       {
3946         for(anObjIter.Initialize(anObjList); anObjIter.More(); anObjIter.Next())
3947         {
3948           anObj = anObjIter.Value();
3949           if(!InList(anAISContext, anObj, aMode))
3950             anAISContext->Activate(anObj, aMode);
3951         }
3952       }
3953     }
3954
3955     // Turn off aMode
3956     if(aMode != 0 && !isTurnOn)
3957     {
3958       if(anAISContext->HasOpenedContext())
3959       {
3960         for(anObjIter.Initialize(anObjList); anObjIter.More(); anObjIter.Next())
3961         {
3962           anObj = anObjIter.Value();
3963           if(InList(anAISContext, anObj, aMode))
3964             anAISContext->Deactivate(anObj, aMode);
3965         }
3966       }
3967     }
3968   }
3969
3970   // Set new selection mode for named object
3971   else
3972   {
3973     // Get argumnets
3974     Standard_Integer aMode = atoi(argv[2]);
3975     Standard_Boolean isTurnOn = atoi(argv[3]);
3976     TCollection_AsciiString aName(argv[1]);
3977
3978     // Check if there is an object with given name in context
3979     if(GetMapOfAIS().IsBound2(aName))
3980     {
3981       anObj = Handle(AIS_InteractiveObject)::
3982         DownCast(GetMapOfAIS().Find2(aName));
3983       if(anObj.IsNull())
3984       {
3985         std::cout << "vselmode error : object name is used for non AIS viewer\n";
3986         return 1; // TCL_ERROR
3987       }
3988     }
3989
3990     if(aMode == 0)
3991     {
3992       if(anAISContext->HasOpenedContext())
3993         anAISContext->CloseLocalContext();
3994     }
3995     // Turn on aMode
3996     if(aMode != 0 && isTurnOn)
3997     {
3998       if(!anAISContext->HasOpenedContext())
3999       {
4000         anAISContext->OpenLocalContext();
4001         anAISContext->Activate(anObj, aMode);
4002       }
4003       else
4004       {
4005         if(!InList(anAISContext, anObj, aMode))
4006           anAISContext->Activate(anObj, aMode);
4007       }
4008     }
4009
4010     // Turn off aMode
4011     if(aMode != 0 && !isTurnOn)
4012     {
4013       if(anAISContext->HasOpenedContext())
4014       {
4015         if(InList(anAISContext, anObj, aMode))
4016           anAISContext->Deactivate(anObj, aMode);
4017       }
4018     }
4019   }
4020   return 0;
4021 }
4022
4023 //==========================================================================
4024 //class   : Triangle
4025 //purpose : creates Triangle based on AIS_InteractiveObject.
4026 //          This class was implemented for testing Select3D_SensitiveTriangle
4027 //===========================================================================
4028 DEFINE_STANDARD_HANDLE(Triangle, AIS_InteractiveObject)
4029 class Triangle: public AIS_InteractiveObject
4030 {
4031 public:
4032   // CASCADE RTTI
4033   DEFINE_STANDARD_RTTI(FilledCircle);
4034   Triangle (const gp_Pnt& theP1,
4035             const gp_Pnt& theP2,
4036             const gp_Pnt& theP3);
4037 protected:
4038   void Compute (  const Handle(PrsMgr_PresentationManager3d)& thePresentationManager,
4039                   const Handle(Prs3d_Presentation)& thePresentation,
4040                   const Standard_Integer theMode);
4041
4042   void ComputeSelection (  const Handle(SelectMgr_Selection)& theSelection,
4043                            const Standard_Integer theMode);
4044 private:
4045   gp_Pnt myPoint1;
4046   gp_Pnt myPoint2;
4047   gp_Pnt myPoint3;
4048 };
4049 IMPLEMENT_STANDARD_HANDLE(Triangle, AIS_InteractiveObject)
4050 IMPLEMENT_STANDARD_RTTIEXT(Triangle, AIS_InteractiveObject)
4051
4052 Triangle::Triangle (const gp_Pnt& theP1,
4053                     const gp_Pnt& theP2,
4054                     const gp_Pnt& theP3)
4055 {
4056   myPoint1 = theP1;
4057   myPoint2 = theP2;
4058   myPoint3 = theP3;
4059 }
4060
4061 void Triangle::Compute(const Handle(PrsMgr_PresentationManager3d)& thePresentationManager,
4062                        const Handle(Prs3d_Presentation)& thePresentation,
4063                        const Standard_Integer theMode)
4064 {
4065   thePresentation->Clear();
4066
4067   BRepBuilderAPI_MakeEdge anEdgeMaker1(myPoint1, myPoint2),
4068                           anEdgeMaker2(myPoint2, myPoint3),
4069                           anEdgeMaker3(myPoint3, myPoint1);
4070
4071   TopoDS_Edge anEdge1 = anEdgeMaker1.Edge(),
4072               anEdge2 = anEdgeMaker2.Edge(),
4073               anEdge3 = anEdgeMaker3.Edge();
4074   if(anEdge1.IsNull() || anEdge2.IsNull() || anEdge3.IsNull())
4075     return;
4076
4077   BRepBuilderAPI_MakeWire aWireMaker(anEdge1, anEdge2, anEdge3);
4078   TopoDS_Wire aWire = aWireMaker.Wire();
4079   if(aWire.IsNull()) return;
4080
4081   BRepBuilderAPI_MakeFace aFaceMaker(aWire);
4082   TopoDS_Face aFace = aFaceMaker.Face();
4083   if(aFace.IsNull()) return;
4084
4085   StdPrs_ShadedShape::Add(thePresentation, aFace, myDrawer);
4086 }
4087
4088 void Triangle::ComputeSelection(const Handle(SelectMgr_Selection)& theSelection,
4089                                 const Standard_Integer theMode)
4090 {
4091   Handle(SelectMgr_EntityOwner) anEntityOwner = new SelectMgr_EntityOwner(this);
4092   Handle(Select3D_SensitiveTriangle) aSensTriangle =
4093     new Select3D_SensitiveTriangle(anEntityOwner, myPoint1, myPoint2, myPoint3);
4094   theSelection->Add(aSensTriangle);
4095 }
4096
4097 //===========================================================================
4098 //function : VTriangle
4099 //Draw arg : vtriangle Name PointName PointName PointName
4100 //purpose  : creates and displays Triangle
4101 //===========================================================================
4102
4103 //function: IsPoint
4104 //purpose : checks if the object with theName is AIS_Point,
4105 //          if yes initialize thePoint from MapOfAIS
4106 Standard_Boolean IsPoint (const TCollection_AsciiString& theName,
4107                           Handle(AIS_Point)& thePoint)
4108 {
4109   Handle(AIS_InteractiveObject) anObject =
4110     Handle(AIS_InteractiveObject)::DownCast(GetMapOfAIS().Find2(theName));
4111   if(anObject.IsNull() ||
4112      anObject->Type() != AIS_KOI_Datum ||
4113      anObject->Signature() != 1)
4114   {
4115     return Standard_False;
4116   }
4117   thePoint = Handle(AIS_Point)::DownCast(anObject);
4118   if(thePoint.IsNull())
4119     return Standard_False;
4120   return Standard_True;
4121 }
4122
4123 //function: IsMatch
4124 //purpose: checks if thePoint1 is equal to thePoint2
4125 Standard_Boolean IsMatch (const Handle(Geom_CartesianPoint)& thePoint1,
4126                           const Handle(Geom_CartesianPoint)& thePoint2)
4127 {
4128   if(abs(thePoint1->X()-thePoint2->X()) <= Precision::Confusion() &&
4129      abs(thePoint1->Y()-thePoint2->Y()) <= Precision::Confusion() &&
4130      abs(thePoint1->Z()-thePoint2->Z()) <= Precision::Confusion())
4131   {
4132     return Standard_True;
4133   }
4134   return Standard_False;
4135 }
4136
4137 static Standard_Integer VTriangle (Draw_Interpretor& di,
4138                                    Standard_Integer argc,
4139                                    const char ** argv)
4140 {
4141   // Check arguments
4142   if (argc != 5)
4143   {
4144     std::cout<<"vtriangle error: expects 4 argumnets\n";
4145     return 1; // TCL_ERROR
4146   }
4147
4148   TheAISContext()->CloseAllContexts();
4149
4150   // Get and check values
4151   TCollection_AsciiString aName(argv[1]);
4152
4153   Handle(AIS_Point) aPoint1, aPoint2, aPoint3;
4154   if (!IsPoint(argv[2], aPoint1))
4155   {
4156     std::cout<<"vtriangle error: the 2nd argument must be a point\n";
4157     return 1; // TCL_ERROR
4158   }
4159   if (!IsPoint(argv[3], aPoint2))
4160   {
4161     std::cout<<"vtriangle error: the 3d argument must be a point\n";
4162     return 1; // TCL_ERROR
4163   }
4164   if (!IsPoint(argv[4], aPoint3))
4165   {
4166     std::cout<<"vtriangle error: the 4th argument must be a point\n";
4167     return 1; // TCL_ERROR
4168   }
4169
4170   // Check that points are different
4171   Handle(Geom_CartesianPoint) aCartPoint1 =
4172     Handle(Geom_CartesianPoint)::DownCast(aPoint1->Component());
4173   Handle(Geom_CartesianPoint) aCartPoint2 =
4174     Handle(Geom_CartesianPoint)::DownCast(aPoint2->Component());
4175   // Test aPoint1 = aPoint2
4176   if (IsMatch(aCartPoint1, aCartPoint2))
4177   {
4178     std::cout<<"vtriangle error: the 1st and the 2nd points are equal\n";
4179     return 1; // TCL_ERROR
4180   }
4181   // Test aPoint2 = aPoint3
4182   Handle(Geom_CartesianPoint) aCartPoint3 =
4183     Handle(Geom_CartesianPoint)::DownCast(aPoint3->Component());
4184   if (IsMatch(aCartPoint2, aCartPoint3))
4185   {
4186     std::cout<<"vtriangle error: the 2nd and the 3d points are equal\n";
4187     return 1; // TCL_ERROR
4188   }
4189   // Test aPoint3 = aPoint1
4190   if (IsMatch(aCartPoint1, aCartPoint3))
4191   {
4192     std::cout<<"vtriangle error: the 1st and the 3d points are equal\n";
4193     return 1; // TCL_ERROR
4194   }
4195
4196   // Create triangle
4197   Handle(Triangle) aTriangle = new Triangle(aCartPoint1->Pnt(),
4198                                             aCartPoint2->Pnt(),
4199                                             aCartPoint3->Pnt());
4200
4201   // Check if there is an object with given name
4202   // and remove it from context
4203   if (GetMapOfAIS().IsBound2(aName))
4204   {
4205     Handle(Standard_Transient) anObj = GetMapOfAIS().Find2(aName);
4206     Handle(AIS_InteractiveObject) anInterObj =
4207          Handle(AIS_InteractiveObject)::DownCast(anObj);
4208     TheAISContext()->Remove(anInterObj, Standard_False);
4209     GetMapOfAIS().UnBind2(aName);
4210   }
4211
4212   // Bind triangle to its name
4213   GetMapOfAIS().Bind(aTriangle, aName);
4214
4215   // Display triangle
4216   TheAISContext()->Display(aTriangle);
4217   return 0;
4218 }
4219
4220 //class  : SegmentObject
4221 //purpose: creates segment based on AIS_InteractiveObject.
4222 //         This class was implemented for testing Select3D_SensitiveCurve
4223 DEFINE_STANDARD_HANDLE(SegmentObject, AIS_InteractiveObject)
4224 class SegmentObject: public AIS_InteractiveObject
4225 {
4226 public:
4227   // CASCADE RTTI
4228   DEFINE_STANDARD_RTTI(SegmentObject);
4229   SegmentObject (const gp_Pnt& thePnt1, const gp_Pnt& thePnt2);
4230 protected:
4231   void Compute (const Handle(PrsMgr_PresentationManager3d)& thePresentationManager,
4232                 const Handle(Prs3d_Presentation)& thePresentation,
4233                 const Standard_Integer theMode);
4234
4235   void ComputeSelection (const Handle(SelectMgr_Selection)& theSelection,
4236                          const Standard_Integer theMode);
4237 private:
4238   gp_Pnt myPoint1;
4239   gp_Pnt myPoint2;
4240 };
4241 IMPLEMENT_STANDARD_HANDLE(SegmentObject, AIS_InteractiveObject)
4242 IMPLEMENT_STANDARD_RTTIEXT(SegmentObject, AIS_InteractiveObject)
4243
4244 SegmentObject::SegmentObject (const gp_Pnt& thePnt1, const gp_Pnt& thePnt2)
4245 {
4246   myPoint1 = thePnt1;
4247   myPoint2 = thePnt2;
4248 }
4249
4250 void SegmentObject::Compute (const Handle_PrsMgr_PresentationManager3d &thePresentationManager,
4251                              const Handle_Prs3d_Presentation &thePresentation,
4252                              const Standard_Integer theMode)
4253 {
4254   thePresentation->Clear();
4255   BRepBuilderAPI_MakeEdge anEdgeMaker(myPoint1, myPoint2);
4256   TopoDS_Edge anEdge = anEdgeMaker.Edge();
4257   if (anEdge.IsNull())
4258     return;
4259   BRepAdaptor_Curve aCurveAdaptor(anEdge);
4260   StdPrs_Curve::Add(thePresentation, aCurveAdaptor, myDrawer);
4261 }
4262
4263 void SegmentObject::ComputeSelection (const Handle_SelectMgr_Selection &theSelection,
4264                                       const Standard_Integer theMode)
4265 {
4266   Handle(SelectMgr_EntityOwner) anOwner = new SelectMgr_EntityOwner(this);
4267   Handle(TColgp_HArray1OfPnt) anArray = new TColgp_HArray1OfPnt(1, 2);
4268   anArray->SetValue(1, myPoint1);
4269   anArray->SetValue(2, myPoint2);
4270   Handle(Select3D_SensitiveCurve) aSensCurve =
4271     new Select3D_SensitiveCurve(anOwner, anArray);
4272   theSelection->Add(aSensCurve);
4273 }
4274
4275 //=======================================================================
4276 //function  : VSegment
4277 //Draw args : vsegment Name PointName PointName
4278 //purpose   : creates and displays Segment
4279 //=======================================================================
4280 static Standard_Integer VSegment (Draw_Interpretor& di,
4281                                   Standard_Integer argc,
4282                                   const char ** argv)
4283 {
4284   // Check arguments
4285   if(argc!=4)
4286   {
4287     std::cout<<"vsegment error: expects 3 arguments\n";
4288     return 1; // TCL_ERROR
4289   }
4290
4291   TheAISContext()->CloseAllContexts();
4292
4293   // Get and check arguments
4294   TCollection_AsciiString aName(argv[1]);
4295   Handle(AIS_Point) aPoint1, aPoint2;
4296   if (!IsPoint(argv[2], aPoint1))
4297   {
4298     std::cout<<"vsegment error: the 2nd argument should be a point\n";
4299     return 1; // TCL_ERROR
4300   }
4301   if (!IsPoint(argv[3], aPoint2))
4302   {
4303     std::cout<<"vsegment error: the 3d argument should be a point\n";
4304     return 1; // TCL_ERROR
4305   }
4306   //Check that points are different
4307   Handle(Geom_CartesianPoint) aCartPoint1 =
4308     Handle(Geom_CartesianPoint)::DownCast(aPoint1->Component());
4309   Handle(Geom_CartesianPoint) aCartPoint2 =
4310     Handle(Geom_CartesianPoint)::DownCast(aPoint2->Component());
4311   if(IsMatch(aCartPoint1, aCartPoint2))
4312   {
4313     std::cout<<"vsegment error: equal points\n";
4314     return 1; // TCL_ERROR
4315   }
4316
4317   // Create segment
4318   Handle(SegmentObject) aSegment = new SegmentObject(aCartPoint1->Pnt(), aCartPoint2->Pnt());
4319   // Check if there is an object with given name
4320   // and remove it from context
4321   if (GetMapOfAIS().IsBound2(aName))
4322   {
4323     Handle(Standard_Transient) anObj = GetMapOfAIS().Find2(aName);
4324     Handle(AIS_InteractiveObject) anInterObj =
4325          Handle(AIS_InteractiveObject)::DownCast(anObj);
4326     TheAISContext()->Remove(anInterObj, Standard_False);
4327     GetMapOfAIS().UnBind2(aName);
4328   }
4329
4330   // Bind segment to its name
4331   GetMapOfAIS().Bind(aSegment, aName);
4332
4333   // Display segment
4334   TheAISContext()->Display(aSegment);
4335   return 0;
4336 }
4337
4338 //=======================================================================
4339 //function : VObjZLayer
4340 //purpose  : Set or get z layer id for presentable object
4341 //=======================================================================
4342
4343 static Standard_Integer VObjZLayer (Draw_Interpretor& di,
4344                                     Standard_Integer argc,
4345                                     const char ** argv)
4346 {
4347   Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
4348   if (aContext.IsNull())
4349   {
4350     di << argv[0] << "Call 'vinit' before!\n";
4351     return 1;
4352   }
4353
4354   // get operation
4355   TCollection_AsciiString aOperation;
4356   if (argc >= 2)
4357     aOperation = TCollection_AsciiString (argv [1]);
4358
4359   // check for correct arguments
4360   if (!(argc == 4 && aOperation.IsEqual ("set")) &&
4361       !(argc == 3 && aOperation.IsEqual ("get")))
4362   {
4363     di << "Usage : " << argv[0] << " set/get object [layerid]\n";
4364     di << " set - set layer id for interactive object, layerid - z layer id\n";
4365     di << " get - get layer id of interactive object\n";
4366     di << " argument layerid should be passed for set operation only\n";
4367     return 1;
4368   }
4369
4370   // find object
4371   TCollection_AsciiString aName (argv[2]);
4372   ViewerTest_DoubleMapOfInteractiveAndName& aMap = GetMapOfAIS();
4373   if (!aMap.IsBound2 (aName))
4374   {
4375     di << "Use 'vdisplay' before" << "\n";
4376     return 1;
4377   }
4378
4379   // find interactive object
4380   Handle(Standard_Transient) anObj = GetMapOfAIS().Find2 (aName);
4381   Handle(AIS_InteractiveObject) anInterObj =
4382     Handle(AIS_InteractiveObject)::DownCast (anObj);
4383   if (anInterObj.IsNull())
4384   {
4385     di << "Not an AIS interactive object!\n";
4386     return 1;
4387   }
4388
4389   // process operation
4390   if (aOperation.IsEqual ("set"))
4391   {
4392     Standard_Integer aLayerId = atoi (argv [3]);
4393     aContext->SetZLayer (anInterObj, aLayerId);
4394   }
4395   else if (aOperation.IsEqual ("get"))
4396   {
4397     di << "Z layer id: " << aContext->GetZLayer (anInterObj);
4398   }
4399
4400   return 0;
4401 }
4402
4403 //=======================================================================
4404 //function : VPolygonOffset
4405 //purpose  : Set or get polygon offset parameters
4406 //=======================================================================
4407 static Standard_Integer VPolygonOffset(Draw_Interpretor& di,
4408                                        Standard_Integer argc,
4409                                        const char ** argv)
4410 {
4411   Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
4412   if (aContext.IsNull())
4413   {
4414     std::cout << argv[0] << " Call 'vinit' before!\n";
4415     return 1;
4416   }
4417
4418   if (argc > 2 && argc != 5)
4419   {
4420     std::cout << "Usage : " << argv[0] << " [object [mode factor units]] - sets/gets polygon offset parameters for an object,"
4421       "without arguments prints the default values" << std::endl;
4422     return 1;
4423   }
4424
4425   // find object
4426   Handle(AIS_InteractiveObject) anInterObj;
4427   if (argc >= 2)
4428   {
4429     TCollection_AsciiString aName (argv[1]);
4430     ViewerTest_DoubleMapOfInteractiveAndName& aMap = GetMapOfAIS();
4431     if (!aMap.IsBound2 (aName))
4432     {
4433       std::cout << "Use 'vdisplay' before" << std::endl;
4434       return 1;
4435     }
4436
4437     // find interactive object
4438     Handle(Standard_Transient) anObj = GetMapOfAIS().Find2 (aName);
4439     anInterObj = Handle(AIS_InteractiveObject)::DownCast (anObj);
4440     if (anInterObj.IsNull())
4441     {
4442       std::cout << "Not an AIS interactive object!" << std::endl;
4443       return 1;
4444     }
4445   }
4446
4447   Standard_Integer aMode;
4448   Standard_ShortReal    aFactor, aUnits;
4449   if (argc == 5)
4450   {
4451     aMode   = atoi(argv[2]);
4452     aFactor = (Standard_ShortReal) atof(argv[3]);
4453     aUnits  = (Standard_ShortReal) atof(argv[4]);
4454
4455     anInterObj->SetPolygonOffsets(aMode, aFactor, aUnits);
4456     aContext->UpdateCurrentViewer();
4457     return 0;
4458   }
4459   else if (argc == 2)
4460   {
4461     if (anInterObj->HasPolygonOffsets())
4462     {
4463       anInterObj->PolygonOffsets(aMode, aFactor, aUnits);
4464       std::cout << "Current polygon offset parameters for " << argv[1] << ":" << std::endl;
4465       std::cout << "\tMode: "   << aMode   << std::endl;
4466       std::cout << "\tFactor: " << aFactor << std::endl;
4467       std::cout << "\tUnits: "  << aUnits  << std::endl;
4468       return 0;
4469     }
4470     else
4471     {
4472       std::cout << "Specific polygon offset parameters are not set for " << argv[1] << std::endl;
4473     }
4474   }
4475
4476   std::cout << "Default polygon offset parameters:" << std::endl;
4477   aContext->DefaultDrawer()->ShadingAspect()->Aspect()->PolygonOffsets(aMode, aFactor, aUnits);
4478   std::cout << "\tMode: "   << aMode   << std::endl;
4479   std::cout << "\tFactor: " << aFactor << std::endl;
4480   std::cout << "\tUnits: "  << aUnits  << std::endl;
4481
4482   return 0;
4483 }
4484
4485 //=======================================================================
4486 //function : VShowFaceBoundaries
4487 //purpose  : Set face boundaries drawing on/off for ais object
4488 //=======================================================================
4489 static Standard_Integer VShowFaceBoundary (Draw_Interpretor& di,
4490                                            Standard_Integer argc,
4491                                            const char ** argv)
4492 {
4493   Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext ();
4494   if (aContext.IsNull ())
4495   {
4496     std::cout << argv[0] << " Call 'vinit' before!\n";
4497     return 1;
4498   }
4499
4500   if ((argc != 3 && argc < 6) || argc > 8)
4501   {
4502     std::cout << "Usage :\n " << argv[0]
4503               << " ObjectName isOn [R G B [LineWidth [LineStyle]]]\n"
4504               << "   ObjectName - name of AIS interactive object. \n"
4505               << "                if ObjectName = \"\", then set as default\n"
4506               << "                settings for all newly displayed objects\n"
4507               << "   isOn       - flag indicating whether the boundaries\n"
4508               << "                should be turned on or off (can be set\n"
4509               << "                to 0 (off) or 1 (on)).\n"
4510               << "   R, G, B    - red, green and blue components of boundary\n"
4511               << "                color in range (0 - 255).\n"
4512               << "                (default is (0, 0, 0)\n"
4513               << "   LineWidth  - line width\n"
4514               << "                (default is 1)\n"
4515               << "   LineStyle  - line fill style :\n"
4516               << "                 0 - solid  \n"
4517               << "                 1 - dashed \n"
4518               << "                 2 - dot    \n"
4519               << "                 3 - dashdot\n"
4520               << "                 (default is solid)";
4521     return 1;
4522   }
4523
4524   TCollection_AsciiString aName (argv[1]);
4525
4526   Quantity_Parameter aRed      = 0.0;
4527   Quantity_Parameter aGreen    = 0.0;
4528   Quantity_Parameter aBlue     = 0.0;
4529   Standard_Real      aWidth    = 1.0;
4530   Aspect_TypeOfLine  aLineType = Aspect_TOL_SOLID;
4531
4532   // find object
4533   Handle(AIS_InteractiveObject) anInterObj;
4534
4535   // if name is empty - apply attributes for default aspect
4536   if (!aName.IsEmpty ())
4537   {
4538     ViewerTest_DoubleMapOfInteractiveAndName& aMap = GetMapOfAIS ();
4539     if (!aMap.IsBound2 (aName))
4540     {
4541       std::cout << "Use 'vdisplay' on " << aName << " before" << std::endl;
4542       return 1;
4543     }
4544
4545     // find interactive object
4546     Handle(Standard_Transient) anObj = GetMapOfAIS ().Find2 (aName);
4547     anInterObj = Handle(AIS_InteractiveObject)::DownCast (anObj);
4548     if (anInterObj.IsNull ())
4549     {
4550       std::cout << "Not an AIS interactive object!" << std::endl;
4551       return 1;
4552     }
4553   }
4554
4555   const Handle(Prs3d_Drawer)& aDrawer = (aName.IsEmpty ()) ?
4556     TheAISContext ()->DefaultDrawer () : anInterObj->Attributes ();
4557
4558   // turn boundaries on/off
4559   Standard_Boolean isBoundaryDraw = (atoi (argv[2]) == 1);
4560   aDrawer->SetFaceBoundaryDraw (isBoundaryDraw);
4561
4562   // set boundary line color
4563   if (argc >= 6)
4564   {
4565     // Text color
4566     aRed   = atof (argv[3])/255.;
4567     aGreen = atof (argv[4])/255.;
4568     aBlue  = atof (argv[5])/255.;
4569   }
4570
4571   // set line width
4572   if (argc >= 7)
4573   {
4574     aWidth = (Standard_Real)atof (argv[6]);
4575   }
4576
4577   // select appropriate line type
4578   if (argc == 8)
4579   {
4580     switch (atoi (argv[7]))
4581     {
4582       case 1: aLineType = Aspect_TOL_DASH;    break;
4583       case 2: aLineType = Aspect_TOL_DOT;     break;
4584       case 3: aLineType = Aspect_TOL_DOTDASH; break;
4585       default:
4586         aLineType = Aspect_TOL_SOLID;
4587     }
4588   }
4589
4590   Quantity_Color aColor (aRed, aGreen, aBlue, Quantity_TOC_RGB);
4591
4592   Handle(Prs3d_LineAspect) aBoundaryAspect =
4593     new Prs3d_LineAspect (aColor, aLineType, aWidth);
4594
4595   aDrawer->SetFaceBoundaryAspect (aBoundaryAspect);
4596
4597   TheAISContext()->Redisplay (anInterObj);
4598
4599   return 0;
4600 }
4601
4602 //=======================================================================
4603 //function : ObjectsCommands
4604 //purpose  :
4605 //=======================================================================
4606
4607 void ViewerTest::ObjectCommands(Draw_Interpretor& theCommands)
4608 {
4609   const char *group ="AISObjects";
4610   theCommands.Add("vtrihedron",
4611     "vtrihedron         : vtrihedron name [Xo] [Yo] [Zo] [Zu] [Zv] [Zw] [Xu] [Xv] [Xw] ",
4612     __FILE__,VTrihedron,group);
4613
4614   theCommands.Add("vtri2d",
4615     "vtri2d Name Selection in the viewer only ",
4616     __FILE__,VTrihedron2D ,group);
4617
4618   theCommands.Add("vplanetri",
4619     "vplanetri Name Selection in the viewer only ",
4620     __FILE__,VPlaneTrihedron ,group);
4621
4622   theCommands.Add("vsize",
4623     "vsize       : vsize [name(Default=Current)] [size(Default=100)] ",
4624     __FILE__,VSize,group);
4625
4626   theCommands.Add("vaxis",
4627     "vaxis nom [Xa] [Ya] [Za] [Xb] [Yb] [Zb]",
4628     __FILE__,VAxisBuilder,group);
4629
4630   theCommands.Add("vaxispara",
4631     "vaxispara  nom ",
4632     __FILE__,VAxisBuilder,group);
4633
4634   theCommands.Add("vaxisortho",
4635     "vaxisotho  nom ",
4636     __FILE__,VAxisBuilder,group);
4637
4638   theCommands.Add("vpoint",
4639     "vpoint  PointName [Xa] [Ya] [Za] ",
4640     __FILE__,VPointBuilder,group);
4641
4642   theCommands.Add("vplane",
4643     "vplane  PlaneName [AxisName/PlaneName/PointName] [PointName/PointName/PointName] [Nothing/Nothing/PointName] ",
4644     __FILE__,VPlaneBuilder,group);
4645
4646   theCommands.Add("vplanepara",
4647     "vplanepara  PlaneName  ",
4648     __FILE__,VPlaneBuilder,group);
4649
4650   theCommands.Add("vplaneortho",
4651     "vplaneortho  PlaneName  ",
4652     __FILE__,VPlaneBuilder,group);
4653
4654   theCommands.Add("vline",
4655     "vline: vline LineName [Xa/PointName] [Ya/PointName] [Za] [Xb] [Yb] [Zb]  ",
4656     __FILE__,VLineBuilder,group);
4657
4658   theCommands.Add("vcircle",
4659     "vcircle CircleName [PointName PointName PointName IsFilled]\n\t\t\t\t\t[PlaneName PointName Radius IsFilled]",
4660     __FILE__,VCircleBuilder,group);
4661
4662   theCommands.Add("vdrawtext",
4663     "vdrawtext  : vdrawtext name X Y Z R G B hor_align ver_align angle zoomable height Aspect [Font [isMultiByte]]",
4664     __FILE__,VDrawText,group);
4665
4666   theCommands.Add("vdrawsphere",
4667     "vdrawsphere: vdrawsphere shapeName Fineness [X=0.0 Y=0.0 Z=0.0] [Radius=100.0] [ToShowEdges=0]\n",
4668     __FILE__,VDrawSphere,group);
4669
4670   theCommands.Add("vclipplane",
4671     "vclipplane : vclipplane [x y z dx dy dz] [planeId {on/off/del/display/hide}]",
4672     __FILE__,VClipPlane,group);
4673
4674   theCommands.Add ("vsetlocation",
4675         "vsetlocation : name x y z; set new location for an interactive object",
4676         __FILE__, VSetLocation, group);
4677
4678   theCommands.Add (
4679     "vcomputehlr",
4680     "vcomputehlr: shape hlrname [ eyex eyey eyez lookx looky lookz ]",
4681     __FILE__, VComputeHLR, group);
4682
4683   theCommands.Add("vdrawparray",
4684     "vdrawparray : vdrawparray Name TypeOfArray [vertex = { 'v' x y z [vertex_normal = { 'n' x y z }] [vertex_color = { 'c' r g b }] ] ... [bound = { 'b' vertex_count [bound_color = { 'c' r g b }] ] ... [edge = { 'e' vertex_id [edge_hidden = { 'h' }] ]",
4685     __FILE__,VDrawPArray,group);
4686
4687   theCommands.Add("vconnect",
4688     "vconnect : name Xo Yo Zo Xu Xv Xw Zu Zv Zw object1 object2 ... [color=NAME]",
4689     __FILE__, VConnect, group);
4690
4691   theCommands.Add("vconnectsh",
4692     "vconnectsh : name Xo Yo Zo Xu Xv Xw Zu Zv Zw shape1 shape2 ... [color=NAME]",
4693     __FILE__, VConnectShape, group);
4694
4695   theCommands.Add("vselmode",
4696     "vselmode : [object] mode On/Off (1/0)",
4697     __FILE__, VSetSelectionMode, group);
4698
4699   theCommands.Add("vtriangle",
4700     "vtriangle Name PointName PointName PointName",
4701     __FILE__, VTriangle,group);
4702
4703   theCommands.Add("vsegment",
4704     "vsegment Name PointName PointName",
4705     __FILE__, VSegment,group);
4706
4707   theCommands.Add("vobjzlayer",
4708     "vobjzlayer : set/get object [layerid] - set or get z layer id for the interactive object",
4709     __FILE__, VObjZLayer, group);
4710
4711   theCommands.Add("vpolygonoffset",
4712     "vpolygonoffset : [object [mode factor units]] - sets/gets polygon offset parameters for an object, without arguments prints the default values",
4713     __FILE__, VPolygonOffset, group);
4714
4715   theCommands.Add ("vshowfaceboundary",
4716     "vshowfaceboundary : ObjectName isOn (1/0) [R G B [LineWidth [LineStyle]]]"
4717     "- turns on/off drawing of face boundaries for ais object "
4718     "and defines boundary line style.",
4719     __FILE__, VShowFaceBoundary, group);
4720 }