0023663: Removing 2D viewer library
[occt.git] / src / ViewerTest / ViewerTest_ObjectCommands.cxx
CommitLineData
b311480e 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
7fd59977 21
22
23//===============================================
7fd59977 24// AIS Objects Creation : Datums (axis,trihedrons,lines,planes)
7fd59977 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
161c4476 41#include <OSD_Chronometer.hxx>
7fd59977 42#include <TCollection_AsciiString.hxx>
4952a30a 43#include <Visual3d_View.hxx>
7fd59977 44#include <V3d_Viewer.hxx>
45#include <V3d_View.hxx>
4952a30a 46#include <V3d_Plane.hxx>
7fd59977 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>
29d43f9c
A
93#include <gp_Trsf.hxx>
94#include <TopLoc_Location.hxx>
3fc57801 95
96#include <HLRAlgo_Projector.hxx>
97#include <HLRBRep_PolyAlgo.hxx>
98#include <HLRBRep_PolyHLRToShape.hxx>
99#include <Aspect_Window.hxx>
100
9558a876
A
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
329843e2
A
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>
a2d5ab2e 126#include <TopoDS_Wire.hxx>
ac04d101
SA
127
128#include <AIS_ConnectedShape.hxx>
792c785c 129#include <AIS_MultipleConnectedInteractive.hxx>
130#include <AIS_MultipleConnectedShape.hxx>
ac04d101
SA
131#include <TopLoc_Location.hxx>
132#include <TColStd_ListOfInteger.hxx>
133#include <TColStd_ListIteratorOfListOfInteger.hxx>
329843e2 134
ceae62f0
A
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
a2d5ab2e 143#include <Prs3d_LineAspect.hxx>
144
7fd59977 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
154extern ViewerTest_DoubleMapOfInteractiveAndName& GetMapOfAIS();
9558a876
A
155extern Standard_Boolean VDisplayAISObject (const TCollection_AsciiString& theName,
156 const Handle(AIS_InteractiveObject)& theAISObj,
157 Standard_Boolean theReplaceIfExists = Standard_True);
7fd59977 158Standard_IMPORT int ViewerMainLoop(Standard_Integer argc, const char** argv);
159extern Handle(AIS_InteractiveContext)& TheAISContext();
160
161
162//==============================================================================
163//function : Vtrihedron 2d
164//purpose : Create a plane with a 2D trihedron from a faceselection
161c4476 165//Draw arg : vtri2d name
7fd59977 166//==============================================================================
167#include <AIS_PlaneTrihedron.hxx>
168
169
170
171static 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;
161c4476 179 // Fermeture des contextes
7fd59977 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() );
161c4476 207 // declarations
7fd59977 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
161c4476 241 return 0;
7fd59977 242}
243
244
245
246//==============================================================================
247//function : VTriherdron
7fd59977 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
dc9b6d23 253static int VTrihedron (Draw_Interpretor& theDi,
254 Standard_Integer theArgsNb,
255 const char** theArgVec)
7fd59977 256{
dc9b6d23 257 if (theArgsNb != 2 && theArgsNb != 5 && theArgsNb != 11)
258 {
259 theDi << theArgVec[0] << " Syntax error\n";
260 return 1;
7fd59977 261 }
7fd59977 262
dc9b6d23 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 }
7fd59977 285
dc9b6d23 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 }
7fd59977 291
dc9b6d23 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);
161c4476 295 return 0;
7fd59977 296}
297
7fd59977 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
307static 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;
161c4476 314 Standard_Boolean hascol;
7fd59977 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
161c4476 330 if(TheAISContext()->HasOpenedContext())
7fd59977 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 //===============================================================
161c4476 342 if (!ThereIsName && ThereIsCurrent)
7fd59977 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
161c4476 356 // On verifie que l'AIS InteraciveObject selectionne est bien
7fd59977 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
161c4476 415 // On verifie que l'AIS InteraciveObject est bien
7fd59977 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 }
161c4476 448 return 0;
7fd59977 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
161c4476 457//Draw arg : vplanetri name
7fd59977 458//==============================================================================
459#include <AIS_Plane.hxx>
460
461
462
463static 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
161c4476 474 // On recupere tous les trihedrons de la GetMapOfAIS()
7fd59977 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
161c4476 521 return 0;
7fd59977 522}
523
524
525
526//==============================================================================
527// Fonction First click 2de click
161c4476 528//
7fd59977 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
161c4476 538//purpose :
7fd59977 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
161c4476 546static int VAxisBuilder(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
7fd59977 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) ) { }
161c4476 596 // fin de la boucle
7fd59977 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) ) { }
161c4476 620 // fin de la boucle
7fd59977 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
161c4476 631 // Construction de l'axe
7fd59977 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);
161c4476 640 }
7fd59977 641 else {
642 // Un unique edge (ShapeA) a ete picke
643 // Fermeture du context local
644 TheAISContext()->CloseLocalContext(MyCurrentIndex);
161c4476 645 // Constuction de l'axe
7fd59977 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
161c4476 668 // Active le mode edge
7fd59977 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) ) { }
161c4476 677 // fin de la boucle
7fd59977 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) ) { }
161c4476 693 // fin de la boucle
7fd59977 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
161c4476 724 // Active le mode edge
7fd59977 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) ) { }
161c4476 733 // fin de la boucle
7fd59977 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) ) { }
161c4476 749 // fin de la boucle
7fd59977 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
161c4476 783//
7fd59977 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
161c4476 799static int VPointBuilder(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
7fd59977 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//==============================================================================
ceae62f0 884// Function 1st click 2de click 3de click
7fd59977 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
ceae62f0 897//purpose : Build an AIS_Plane from selected entities or Named AIS components
7fd59977 898//Draw arg : vplane PlaneName [AxisName] [PointName]
899// [PointName] [PointName] [PointName]
900// [PlaneName] [PointName]
901//==============================================================================
902
ceae62f0
A
903static Standard_Integer VPlaneBuilder (Draw_Interpretor& di,
904 Standard_Integer argc,
905 const char** argv)
7fd59977 906{
907 // Declarations
ceae62f0
A
908 Standard_Boolean hasArg;
909 TCollection_AsciiString aName;
910 Standard_Integer aCurrentIndex;
7fd59977 911
912 // Verification
ceae62f0
A
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;
7fd59977 922
ceae62f0
A
923 aName=argv[1];
924 // Close all contexts
7fd59977 925 TheAISContext()->CloseAllContexts();
926
ceae62f0
A
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 =
7fd59977 937 Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2(argv[2] ));
938
ceae62f0
A
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 =
7fd59977 952 Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2(argv[3]));
ceae62f0
A
953 // If B is not an AIS_Point
954 if (aShapeB.IsNull() ||
955 (!(aShapeB->Type()==AIS_KOI_Datum && aShapeB->Signature()==1)))
7fd59977 956 {
ceae62f0 957 std::cout<<"vplane: error 2nd object is expected to be an AIS_Point.\n";
7fd59977 958 return 1;
959 }
ceae62f0
A
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 =
7fd59977 968 Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2(argv[4]));
ceae62f0
A
969 // If C is not an AIS_Point
970 if (aShapeC.IsNull() ||
971 (!(aShapeC->Type()==AIS_KOI_Datum && aShapeC->Signature()==1)))
7fd59977 972 {
ceae62f0 973 std::cout<<"vplane: error 3d object is expected to be an AIS_Point.\n";
7fd59977 974 return 1;
975 }
976
ceae62f0
A
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);
7fd59977 982
ceae62f0
A
983 Handle(Geom_CartesianPoint ) aCartPointA =
984 Handle(Geom_CartesianPoint)::DownCast( anAISPointA->Component());
7fd59977 985
ceae62f0
A
986 Handle(Geom_CartesianPoint ) aCartPointB =
987 Handle(Geom_CartesianPoint)::DownCast( anAISPointB->Component());
7fd59977 988
ceae62f0
A
989 Handle(Geom_CartesianPoint ) aCartPointC =
990 Handle(Geom_CartesianPoint)::DownCast( anAISPointC->Component());
7fd59977 991
ceae62f0
A
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 {
7fd59977 997 // B=A
ceae62f0 998 std::cout<<"vplane error: same points"<<"\n";return 1;
7fd59977 999 }
ceae62f0
A
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 {
7fd59977 1004 // C=A
ceae62f0 1005 std::cout<<"vplane error: same points"<<"\n";return 1;
7fd59977 1006 }
ceae62f0
A
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 {
7fd59977 1011 // C=B
ceae62f0 1012 std::cout<<"vplane error: same points"<<"\n";return 1;
7fd59977 1013 }
1014
ceae62f0
A
1015 gp_Pnt A = aCartPointA->Pnt();
1016 gp_Pnt B = aCartPointB->Pnt();
1017 gp_Pnt C = aCartPointC->Pnt();
7fd59977 1018
ceae62f0 1019 // Construction of AIS_Plane
7fd59977 1020 GC_MakePlane MkPlane (A,B,C);
ceae62f0
A
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);
7fd59977 1025 }
1026
ceae62f0
A
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
7fd59977 1031 if (argc!=4 || !GetMapOfAIS().IsBound2(argv[3] ) )
1032 {
ceae62f0 1033 std::cout<<"vplane: error 2d name doesn't exist in the GetMapOfAIS()\n";
7fd59977 1034 return 1;
1035 }
ceae62f0
A
1036 // Get shape from map
1037 Handle(AIS_InteractiveObject) aShapeB =
7fd59977 1038 Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2(argv[3]));
ceae62f0
A
1039 // If B is not an AIS_Point
1040 if (aShapeB.IsNull() ||
1041 (!(aShapeB->Type()==AIS_KOI_Datum && aShapeB->Signature()==1)))
7fd59977 1042 {
ceae62f0 1043 std::cout<<"vplane: error 2d object is expected to be an AIS_Point\n";
7fd59977 1044 return 1;
1045 }
1046
ceae62f0
A
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);
7fd59977 1050
ceae62f0
A
1051 Handle(Geom_Line ) aGeomLineA = anAISAxisA ->Component();
1052 Handle(Geom_Point) aGeomPointB = anAISPointB->Component() ;
7fd59977 1053
ceae62f0
A
1054 gp_Ax1 anAxis = aGeomLineA->Position();
1055 Handle(Geom_CartesianPoint) aCartPointB =
1056 Handle(Geom_CartesianPoint)::DownCast(aGeomPointB);
7fd59977 1057
ceae62f0
A
1058 gp_Dir D =anAxis.Direction();
1059 gp_Pnt B = aCartPointB->Pnt();
7fd59977 1060
ceae62f0
A
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);
7fd59977 1066
1067 }
ceae62f0
A
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";
7fd59977 1076 return 1;
1077 }
ceae62f0
A
1078 // Get shape from map
1079 Handle(AIS_InteractiveObject) aShapeB =
7fd59977 1080 Handle(AIS_InteractiveObject)::DownCast (GetMapOfAIS().Find2(argv[3]));
ceae62f0
A
1081 // B should be an AIS_Point
1082 if (aShapeB.IsNull() ||
1083 (!(aShapeB->Type()==AIS_KOI_Datum && aShapeB->Signature()==1)))
7fd59977 1084 {
ceae62f0 1085 std::cout<<"vplane: error 2d object is expected to be an AIS_Point\n";
7fd59977 1086 return 1;
1087 }
1088
ceae62f0
A
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);
7fd59977 1092
ceae62f0
A
1093 Handle(Geom_Plane) aNewGeomPlane= anAISPlaneA->Component();
1094 Handle(Geom_Point) aGeomPointB = anAISPointB->Component();
7fd59977 1095
ceae62f0
A
1096 Handle(Geom_CartesianPoint) aCartPointB =
1097 Handle(Geom_CartesianPoint)::DownCast(aGeomPointB);
1098 gp_Pnt B= aCartPointB->Pnt();
7fd59977 1099
ceae62f0
A
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;
7fd59977 1110 }
7fd59977 1111 }
ceae62f0
A
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 {
7fd59977 1119 TheAISContext()->OpenLocalContext();
ceae62f0 1120 aCurrentIndex=TheAISContext()->IndexOfCurrentLocal();
7fd59977 1121
ceae62f0
A
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";
7fd59977 1127
ceae62f0 1128 // Wait for picking
7fd59977 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) ) { }
ceae62f0 1133 // end of the loop
7fd59977 1134
ceae62f0
A
1135 TopoDS_Shape aShapeA;
1136 for (TheAISContext()->InitSelected();
1137 TheAISContext()->MoreSelected();
1138 TheAISContext()->NextSelected())
1139 {
1140 aShapeA = TheAISContext()->SelectedShape();
7fd59977 1141 }
1142
ceae62f0
A
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";
7fd59977 1148
ceae62f0 1149 // Wait for picking
7fd59977 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) ) { }
ceae62f0 1154 // end of the loop
7fd59977 1155
ceae62f0
A
1156 TopoDS_Shape aShapeB;
1157 for (TheAISContext()->InitSelected();
1158 TheAISContext()->MoreSelected();
1159 TheAISContext()->NextSelected())
1160 {
1161 aShapeB = TheAISContext()->SelectedShape();
7fd59977 1162 }
ceae62f0
A
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";
7fd59977 1174
ceae62f0 1175 // Wait for picking
7fd59977 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) ) { }
ceae62f0 1180 // end of the loop
7fd59977 1181
ceae62f0
A
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;
7fd59977 1194 }
7fd59977 1195
ceae62f0
A
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);
7fd59977 1208 }
ceae62f0
A
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);
7fd59977 1215
ceae62f0
A
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);
7fd59977 1238 }
7fd59977 1239 }
7fd59977 1240 }
ceae62f0
A
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";
7fd59977 1247
ceae62f0 1248 // Wait for picking
7fd59977 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) ) { }
ceae62f0 1253 // end of the loop
7fd59977 1254
ceae62f0
A
1255 TopoDS_Shape aShapeB;
1256 for (TheAISContext()->InitSelected();
1257 TheAISContext()->MoreSelected();
1258 TheAISContext()->NextSelected())
1259 {
1260 aShapeB = TheAISContext()->SelectedShape();
7fd59977 1261 }
ceae62f0
A
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;
7fd59977 1273 }
ceae62f0
A
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);
7fd59977 1284 GC_MakePlane MkPlane (B,Aa,Ab);
ceae62f0
A
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);
7fd59977 1289 }
7fd59977 1290 }
ceae62f0
A
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);
7fd59977 1306 }
ceae62f0
A
1307 else
1308 {
1309 std::cout<<" vplane: error\n";
1310 return 1;
7fd59977 1311 }
7fd59977 1312 }
7fd59977 1313 }
1314
ceae62f0 1315 // Function vPlanePara
7fd59977 1316 // ===================
ceae62f0
A
1317 // test the constructor AIS_Plane::AIS_Plane(Geom_Plane,gp_Pnt)
1318 else if (!strcasecmp(argv[0], "vplanepara"))
1319 {
7fd59977 1320 TheAISContext()->OpenLocalContext();
ceae62f0 1321 aCurrentIndex = TheAISContext()->IndexOfCurrentLocal();
7fd59977 1322
ceae62f0
A
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";
7fd59977 1327
ceae62f0 1328 // Wait for picking
7fd59977 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) ) { }
ceae62f0 1333 // end of the loop
7fd59977 1334
ceae62f0
A
1335 TopoDS_Shape aShapeA;
1336 for (TheAISContext()->InitSelected();
1337 TheAISContext()->MoreSelected();
1338 TheAISContext()->NextSelected())
1339 {
1340 aShapeA = TheAISContext()->SelectedShape();
7fd59977 1341 }
1342
ceae62f0
A
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";
7fd59977 1349
ceae62f0 1350 // Wait for picking
7fd59977 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) ) { }
ceae62f0 1355 // end of the loop
7fd59977 1356
ceae62f0
A
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();
7fd59977 1364 }
1365
ceae62f0
A
1366 // Close the local context
1367 TheAISContext()->CloseLocalContext(aCurrentIndex);
7fd59977 1368
ceae62f0
A
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);
7fd59977 1383 }
ceae62f0
A
1384 else
1385 {
1386 std::cout<<" vplanepara: error\n";
1387 return 1;
7fd59977 1388 }
7fd59977 1389 }
ceae62f0
A
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";
7fd59977 1396
ceae62f0 1397 // Wait for picking
7fd59977 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) ) { }
ceae62f0 1402 // end of the loop
7fd59977 1403
ceae62f0
A
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();
7fd59977 1411 }
ceae62f0
A
1412 // Close the local context
1413 TheAISContext()->CloseLocalContext(aCurrentIndex);
7fd59977 1414
ceae62f0
A
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);
7fd59977 1429 }
ceae62f0
A
1430 else
1431 {
1432 std::cout<<" vplanepara: error"<<"\n";return 1;
7fd59977 1433 }
7fd59977 1434 }
7fd59977 1435 }
1436
ceae62f0 1437 // Function vplaneortho
7fd59977 1438 // ====================
ceae62f0
A
1439 // test the constructor AIS_Plane::AIS_Plane(Geom_Plane,gp_Pnt,gp_Pnt,gp_Pnt)
1440 else
1441 {
7fd59977 1442 TheAISContext()->OpenLocalContext();
ceae62f0 1443 aCurrentIndex = TheAISContext()->IndexOfCurrentLocal();
7fd59977 1444
ceae62f0
A
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";
7fd59977 1449
ceae62f0 1450 // Wait for picking
7fd59977 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) ) { }
ceae62f0 1455 // end of the loop
7fd59977 1456
ceae62f0
A
1457 TopoDS_Shape aShapeA;
1458 for (TheAISContext()->InitSelected();
1459 TheAISContext()->MoreSelected();
1460 TheAISContext()->NextSelected())
1461 {
1462 aShapeA = TheAISContext()->SelectedShape();
7fd59977 1463 }
1464
ceae62f0
A
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";
7fd59977 1470
ceae62f0 1471 // Wait for picking
7fd59977 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) ) { }
ceae62f0 1476 // end of the loop
7fd59977 1477
ceae62f0
A
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();
7fd59977 1485 }
1486
ceae62f0
A
1487 // Close the local context
1488 TheAISContext()->CloseLocalContext(aCurrentIndex);
7fd59977 1489
ceae62f0
A
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);
7fd59977 1497
1498 gp_Dir Dab (ab);
ceae62f0
A
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;
7fd59977 1513 }
ceae62f0
A
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);
7fd59977 1528 }
ceae62f0
A
1529 else
1530 {
1531 std::cout<<" vplaneortho: error\n";
1532 return 1;
7fd59977 1533 }
7fd59977 1534 }
ceae62f0
A
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";
7fd59977 1540
ceae62f0 1541 // Wait for picking
7fd59977 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) ) { }
ceae62f0 1546 // end of the loop
7fd59977 1547
ceae62f0
A
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();
7fd59977 1555 }
ceae62f0
A
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);
7fd59977 1566 gp_Dir Dab (ab);
ceae62f0
A
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;
7fd59977 1581 }
ceae62f0
A
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);
7fd59977 1595 }
ceae62f0
A
1596 else
1597 {
1598 std::cout<<" vplaneortho: error\n";
1599 return 1;
7fd59977 1600 }
7fd59977 1601 }
7fd59977 1602 }
7fd59977 1603 }
1604 return 0;
7fd59977 1605}
1606
1607
1608//==============================================================================
1609// Fonction vline
1610// --------------- Uniquement par parametre. Pas de selection dans le viewer.
1611//==============================================================================
1612
1613//==============================================================================
1614//function : VLineBuilder
161c4476 1615//purpose : Build an AIS_Line
7fd59977 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
161c4476 1623static int VLineBuilder(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
7fd59977 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 }
161c4476 1653 else {di <<"vline error: wrong type of 1st argument."<<"\n";return 1; }
7fd59977 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) {
161c4476 1681 // On verifie que les deux points ne sont pas confondus
7fd59977 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) ) { }
161c4476 1734 // fin de la boucle
7fd59977 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
329843e2
A
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
1778Handle(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
1786DEFINE_STANDARD_HANDLE(FilledCircle, AIS_InteractiveObject)
1787
1788class FilledCircle : public AIS_InteractiveObject
1789{
1790public:
1791 // CASCADE RTTI
1792 DEFINE_STANDARD_RTTI(FilledCircle);
1793
1794 FilledCircle(gp_Pnt theCenter, Standard_Real theRadius);
1795 FilledCircle(Handle(Geom_Circle) theCircle);
1796
1797private:
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
1808protected:
1809 Handle(Geom_Circle) myCircle;
1810 Standard_Boolean myFilledStatus;
1811
1812};
1813
1814IMPLEMENT_STANDARD_HANDLE(FilledCircle, AIS_InteractiveObject)
1815IMPLEMENT_STANDARD_RTTIEXT(FilledCircle, AIS_InteractiveObject)
1816
1817FilledCircle::FilledCircle(gp_Pnt theCenter, Standard_Real theRadius)
1818{
1819 myCircle = CreateCircle(theCenter, theRadius);
1820 myFilledStatus = Standard_True;
1821}
1822
1823FilledCircle::FilledCircle(Handle(Geom_Circle) theCircle)
1824{
1825 myCircle = theCircle;
1826 myFilledStatus = Standard_True;
1827}
1828
1829TopoDS_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
1846void 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
1860void 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}
7fd59977 1868
1869//==============================================================================
1870// Fonction vcircle
1871// ----------------- Uniquement par parametre. Pas de selection dans le viewer.
1872//==============================================================================
1873
1874//==============================================================================
1875//function : VCircleBuilder
161c4476 1876//purpose : Build an AIS_Circle
329843e2
A
1877//Draw arg : vcircle CircleName PlaneName PointName Radius IsFilled
1878// PointName PointName PointName IsFilled
7fd59977 1879//==============================================================================
329843e2
A
1880
1881void 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}
7fd59977 1913
161c4476 1914static int VCircleBuilder(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
7fd59977 1915{
1916 Standard_Integer myCurrentIndex;
329843e2
A
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 }
7fd59977 1923 TheAISContext()->CloseAllContexts();
1924
329843e2
A
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
7fd59977 1932 Handle(AIS_InteractiveObject) theShapeA;
1933 Handle(AIS_InteractiveObject) theShapeB;
1934
329843e2
A
1935 theShapeA =
1936 Handle(AIS_InteractiveObject)::DownCast(GetMapOfAIS().Find2(argv[2]));
1937 theShapeB =
1938 Handle(AIS_InteractiveObject)::DownCast(GetMapOfAIS().Find2(argv[3]));
1939
7fd59977 1940
1941 // Arguments: AIS_Point AIS_Point AIS_Point
1942 // ========================================
329843e2 1943 if (!theShapeA.IsNull() && !theShapeB.IsNull() &&
7fd59977 1944 theShapeA->Type()==AIS_KOI_Datum && theShapeA->Signature()==1)
1945 {
329843e2
A
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
7fd59977 1950 }
329843e2 1951 // The third object must be a point
7fd59977 1952 Handle(AIS_InteractiveObject) theShapeC =
329843e2 1953 Handle(AIS_InteractiveObject)::DownCast(GetMapOfAIS().Find2(argv[4]));
7fd59977 1954 if (theShapeC.IsNull() ||
329843e2
A
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 }
7fd59977 1960 // tag
329843e2
A
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);
7fd59977 1977
1978 // Test A=B
329843e2
A
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
7fd59977 1985 }
1986 // Test A=C
329843e2
A
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
7fd59977 1993 }
1994 // Test B=C
329843e2
A
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
7fd59977 2001 }
329843e2
A
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);
7fd59977 2017 }
2018
329843e2 2019 // Arguments: AIS_Plane AIS_Point Real
7fd59977 2020 // ===================================
329843e2
A
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
7fd59977 2035 }
7fd59977 2036
329843e2
A
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);
7fd59977 2040
329843e2
A
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);
7fd59977 2045
2046 gp_Pln mygpPlane = myGeomPlane->Pln();
2047 gp_Ax1 thegpAxe = mygpPlane.Axis();
2048 gp_Dir theDir = thegpAxe.Direction();
329843e2 2049 gp_Pnt theCenter = myCartPointB->Pnt();
7fd59977 2050 Standard_Real TheR = atof(argv[4]);
329843e2
A
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);
7fd59977 2064
2065 }
2066
2067 // Error
329843e2
A
2068 else
2069 {
2070 std::cout << "vcircle error: 1st argument is a unexpected type.\n";
2071 return 1; // TCL_ERROR
7fd59977 2072 }
2073
2074 }
329843e2 2075 // No arguments: selection in the viewer
7fd59977 2076 // =========================================
329843e2
A
2077 else
2078 {
2079 // Get the name of the circle
2080 TCollection_AsciiString aName(argv[1]);
7fd59977 2081
2082 TheAISContext()->OpenLocalContext();
329843e2 2083 myCurrentIndex = TheAISContext()->IndexOfCurrentLocal();
7fd59977 2084
329843e2 2085 // Activate selection mode for vertices and faces
7fd59977 2086 TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(1) );
2087 TheAISContext()->ActivateStandardMode (AIS_Shape::SelectionType(4) );
ceae62f0 2088 std::cout << " Select a vertex or a face\n";
7fd59977 2089
329843e2 2090 // Wait for picking
7fd59977 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) ) { }
329843e2 2095 // end of the loop
7fd59977 2096
2097 TopoDS_Shape ShapeA;
329843e2
A
2098 for(TheAISContext()->InitSelected();
2099 TheAISContext()->MoreSelected();
2100 TheAISContext()->NextSelected() )
2101 {
7fd59977 2102 ShapeA = TheAISContext()->SelectedShape();
2103 }
2104
329843e2
A
2105 // ShapeA is a Vertex
2106 if (ShapeA.ShapeType() == TopAbs_VERTEX )
2107 {
7fd59977 2108 TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(4) );
ceae62f0 2109 std::cout << " Select a different vertex\n";
7fd59977 2110
2111 TopoDS_Shape ShapeB;
329843e2
A
2112 do
2113 {
2114 // Wait for picking
7fd59977 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) ) { }
329843e2 2119 // end of the loop
7fd59977 2120
329843e2
A
2121 for(TheAISContext()->InitSelected();
2122 TheAISContext()->MoreSelected();
2123 TheAISContext()->NextSelected() )
2124 {
7fd59977 2125 ShapeB = TheAISContext()->SelectedShape();
2126 }
7fd59977 2127 } while(ShapeB.IsSame(ShapeA) );
2128
329843e2 2129 // Selection of ShapeC
ceae62f0 2130 std::cout << " Select the last vertex\n";
7fd59977 2131 TopoDS_Shape ShapeC;
329843e2
A
2132 do
2133 {
2134 // Wait for picking
7fd59977 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) ) { }
329843e2 2139 // end of the loop
7fd59977 2140
329843e2
A
2141 for(TheAISContext()->InitSelected();
2142 TheAISContext()->MoreSelected();
2143 TheAISContext()->NextSelected() )
2144 {
7fd59977 2145 ShapeC = TheAISContext()->SelectedShape();
2146 }
7fd59977 2147 } while(ShapeC.IsSame(ShapeA) || ShapeC.IsSame(ShapeB) );
329843e2
A
2148
2149 // Get isFilled
2150 Standard_Boolean isFilled;
2151 std::cout << "Enter filled status (0 or 1)\n";
2152 cin >> isFilled;
7fd59977 2153
329843e2 2154 // Close the local context
7fd59977 2155 TheAISContext()->CloseLocalContext(myCurrentIndex);
2156
329843e2
A
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 }
7fd59977 2173
329843e2 2174 DisplayCircle(theGeomCircle, aName, isFilled);
7fd59977 2175
2176 }
329843e2 2177 // Shape is a face
ceae62f0 2178 else
329843e2 2179 {
ceae62f0 2180 std::cout << " Select a vertex (in your face)\n";
7fd59977 2181 TheAISContext()->DeactivateStandardMode (AIS_Shape::SelectionType(4) );
2182
2183 TopoDS_Shape ShapeB;
329843e2 2184 // Wait for picking
7fd59977 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) ) { }
329843e2 2189 // end of the loop
7fd59977 2190
329843e2
A
2191 for(TheAISContext()->InitSelected();
2192 TheAISContext()->MoreSelected();
2193 TheAISContext()->NextSelected() )
2194 {
7fd59977 2195 ShapeB = TheAISContext()->SelectedShape();
2196 }
2197
329843e2
A
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;
7fd59977 2210
329843e2 2211 // Close the local context
7fd59977 2212 TheAISContext()->CloseLocalContext(myCurrentIndex);
329843e2 2213 // Construction of the circle
7fd59977 2214
329843e2
A
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);
7fd59977 2220 gp_Pln mygpPlane = theGeomPlane->Pln();
2221 gp_Ax1 thegpAxe = mygpPlane.Axis();
2222 gp_Dir theDir = thegpAxe.Direction();
2223
329843e2
A
2224 // Recover the center
2225 gp_Pnt theCenter = BRep_Tool::Pnt(TopoDS::Vertex(ShapeB));
7fd59977 2226
329843e2
A
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 }
7fd59977 2239
329843e2
A
2240 DisplayCircle(theGeomCircle, aName, isFilled);
2241
7fd59977 2242 }
2243
7fd59977 2244 }
2245
2246 return 0;
2247}
2248
ceae62f0 2249
7fd59977 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>
7fd59977 2258#include <Graphic3d_AspectText3d.hxx>
161c4476 2259#include <Graphic3d_AspectFillArea3d.hxx>
7fd59977 2260#include <Graphic3d_StructureManager.hxx>
2261#include <Graphic3d_VerticalTextAlignment.hxx>
2262#include <Graphic3d_HorizontalTextAlignment.hxx>
2263
aff395a3 2264#include <Font_NameOfFont.hxx>
2265
7fd59977 2266#include <Visual3d_ViewManager.hxx>
2267#include <ViewerTest_Tool.ixx>
2268
2269#include <Standard_DefineHandle.hxx>
2270
7fd59977 2271#include <Prs3d_Root.hxx>
2272#include <Prs3d_Text.hxx>
2273#include <Prs3d_TextAspect.hxx>
7fd59977 2274#include <Prs3d_ShadingAspect.hxx>
2275#include <PrsMgr_PresentationManager3d.hxx>
2276
2277#include <TCollection_ExtendedString.hxx>
2278#include <TCollection_AsciiString.hxx>
2279
2280#include <gp_Pnt.hxx>
2281#include <Quantity_NameOfColor.hxx>
161c4476 2282#include <Quantity_Color.hxx>
7fd59977 2283
2284
2285DEFINE_STANDARD_HANDLE(MyTextClass, AIS_InteractiveObject)
2286
13a22457
S
2287class MyTextClass:public AIS_InteractiveObject
2288{
7fd59977 2289public:
2290 // CASCADE RTTI
2291 DEFINE_STANDARD_RTTI(MyTextClass );
2292
2293 MyTextClass(){};
2294
161c4476 2295 MyTextClass
7fd59977 2296 (
2297 const TCollection_ExtendedString& , const gp_Pnt& ,
161c4476
K
2298 Quantity_Color color,
2299 Standard_Integer aHJust,
7fd59977 2300 Standard_Integer aVJust ,
161c4476
K
2301 Standard_Real Angle ,
2302 Standard_Boolean Zoom ,
2303 Standard_Real Height,
eeaaaefb 2304 Font_FontAspect FontAspect,
7fd59977 2305 Standard_CString Font
2306 );
2307
2308private:
2309
2310 void Compute ( const Handle(PrsMgr_PresentationManager3d)& aPresentationManager,
2311 const Handle(Prs3d_Presentation)& aPresentation,
2312 const Standard_Integer aMode);
2313
2314 void ComputeSelection ( const Handle(SelectMgr_Selection)& aSelection,
161c4476 2315 const Standard_Integer aMode){} ;
7fd59977 2316
2317protected:
2318 TCollection_ExtendedString aText;
2319 gp_Pnt aPosition;
2320 Standard_Real Red;
2321 Standard_Real Green;
2322 Standard_Real Blue;
2323 Standard_Real aAngle;
161c4476 2324 Standard_Real aHeight;
7fd59977 2325 Standard_Boolean aZoomable;
2326 Quantity_Color aColor;
161c4476 2327 Standard_CString aFont;
eeaaaefb 2328 Font_FontAspect aFontAspect;
7fd59977 2329 Graphic3d_HorizontalTextAlignment aHJustification;
2330 Graphic3d_VerticalTextAlignment aVJustification;
2331};
2332
2333
2334
2335IMPLEMENT_STANDARD_HANDLE(MyTextClass, AIS_InteractiveObject)
161c4476 2336IMPLEMENT_STANDARD_RTTIEXT(MyTextClass, AIS_InteractiveObject)
7fd59977 2337
2338
161c4476
K
2339MyTextClass::MyTextClass( const TCollection_ExtendedString& text, const gp_Pnt& position,
2340 Quantity_Color color = Quantity_NOC_YELLOW,
2341 Standard_Integer aHJust = Graphic3d_HTA_LEFT,
7fd59977 2342 Standard_Integer aVJust = Graphic3d_VTA_BOTTOM,
2343 Standard_Real angle = 0.0 ,
2344 Standard_Boolean zoomable = Standard_True,
2345 Standard_Real height = 12.,
eeaaaefb 2346 Font_FontAspect fontAspect = Font_FA_Regular,
7fd59977 2347 Standard_CString font = "Courier")
2348{
2349 aText = text;
161c4476 2350 aPosition = position;
7fd59977 2351 aHJustification = Graphic3d_HorizontalTextAlignment(aHJust);
2352 aVJustification = Graphic3d_VerticalTextAlignment(aVJust);
2353 aAngle = angle;
161c4476
K
2354 aZoomable = zoomable;
2355 aHeight = height;
7fd59977 2356 aColor = color;
2357 aFontAspect = fontAspect;
2358 aFont = font;
2359};
2360
2361
2362
2363//////////////////////////////////////////////////////////////////////////////
2364void MyTextClass::Compute(const Handle(PrsMgr_PresentationManager3d)& aPresentationManager,
2365 const Handle(Prs3d_Presentation)& aPresentation,
2366 const Standard_Integer aMode)
2367{
2368
2369 aPresentation->Clear();
2370
2371 Handle_Prs3d_TextAspect asp = myDrawer->TextAspect();
2372
2373 asp->SetFont(aFont);
2374 asp->SetColor(aColor);
2375 asp->SetHeight(aHeight); // I am changing the myHeight value
2376
2377 asp->SetHorizontalJustification(aHJustification);
161c4476 2378 asp->SetVerticalJustification(aVJustification);
7fd59977 2379 asp->Aspect()->SetTextZoomable(aZoomable);
2380 asp->Aspect()->SetTextAngle(aAngle);
2381 asp->Aspect()->SetTextFontAspect(aFontAspect);
2382 Prs3d_Text::Draw(aPresentation, asp, aText, aPosition);
161c4476 2383
7fd59977 2384 /* This comment code is worked
2385 Handle(Graphic3d_Group) TheGroup = Prs3d_Root::CurrentGroup(aPresentation);
2386 Handle(Graphic3d_AspectFillArea3d) aspect = myDrawer->ShadingAspect()->Aspect();
2387 Graphic3d_Vertex vertices_text;
2388 vertices_text.SetCoord(aPosition.X(),aPosition.Y(),aPosition.Y());
2389 TheGroup->SetPrimitivesAspect(aspect);
7fd59977 2390 TheGroup->Text(aText,vertices_text,aHeight,Standard_True);
7fd59977 2391 */
2392};
2393
2394static int VDrawText (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
2395{
13a22457
S
2396 // Check arguments
2397 if (argc < 14)
7fd59977 2398 {
13a22457
S
2399 di<<"Error: "<<argv[0]<<" - invalid number of arguments\n";
2400 di<<"Usage: type help "<<argv[0]<<"\n";
2401 return 1; //TCL_ERROR
7fd59977 2402 }
13a22457
S
2403
2404 Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
2405
2406 // Create 3D view if it doesn't exist
2407 if ( aContext.IsNull() )
161c4476 2408 {
13a22457
S
2409 ViewerTest::ViewerInit();
2410 aContext = ViewerTest::GetAISContext();
2411 if( aContext.IsNull() )
2412 {
2413 di << "Error: Cannot create a 3D view\n";
2414 return 1; //TCL_ERROR
2415 }
7fd59977 2416 }
2417
13a22457
S
2418 // Text position
2419 const Standard_Real X = atof(argv[2]);
2420 const Standard_Real Y = atof(argv[3]);
2421 const Standard_Real Z = atof(argv[4]);
2422 const gp_Pnt pnt(X,Y,Z);
7fd59977 2423
13a22457
S
2424 // Text color
2425 const Quantity_Parameter R = atof(argv[5])/255.;
2426 const Quantity_Parameter G = atof(argv[6])/255.;
2427 const Quantity_Parameter B = atof(argv[7])/255.;
2428 const Quantity_Color aColor( R, G, B, Quantity_TOC_RGB );
7fd59977 2429
13a22457
S
2430 // Text alignment
2431 const int hor_align = atoi(argv[8]);
2432 const int ver_align = atoi(argv[9]);
7fd59977 2433
13a22457
S
2434 // Text angle
2435 const Standard_Real angle = atof(argv[10]);
7fd59977 2436
13a22457
S
2437 // Text zooming
2438 const Standard_Boolean zoom = atoi(argv[11]);
2439
2440 // Text height
2441 const Standard_Real height = atof(argv[12]);
2442
2443 // Text aspect
eeaaaefb 2444 const Font_FontAspect aspect = Font_FontAspect(atoi(argv[13]));
13a22457
S
2445
2446 // Text font
2447 TCollection_AsciiString font;
2448 if(argc < 15)
2449 font.AssignCat("Courier");
2450 else
2451 font.AssignCat(argv[14]);
2452
2453 // Text is multibyte
2454 const Standard_Boolean isMultibyte = (argc < 16)? Standard_False : (atoi(argv[15]) != 0);
2455
2456 // Read text string
2457 TCollection_ExtendedString name;
2458 if (isMultibyte)
161c4476 2459 {
13a22457 2460 const char *str = argv[1];
f3f08423 2461 while ( *str || *(str+1)=='\x0A' || *(str+1)=='\x0B' || *(str+1)=='\x0C' || *(str+1)=='\x0D'
2462 || *(str+1)=='\x07' || *(str+1)=='\x08' || *(str+1)=='\x09' )
13a22457
S
2463 {
2464 unsigned short c1 = *str++;
2465 unsigned short c2 = *str++;
f3f08423 2466 if (!c2) break;
13a22457
S
2467 name += (Standard_ExtCharacter)((c1 << 8) | c2);
2468 }
7fd59977 2469 }
13a22457
S
2470 else
2471 {
2472 name += argv[1];
2473 }
2474
2475 if (name.Length())
2476 {
2477 Handle(MyTextClass) myT = new MyTextClass(name,pnt,aColor,hor_align,ver_align,angle,zoom,height,aspect,font.ToCString());
2478 aContext->Display(myT,Standard_True);
2479 }
2480
161c4476 2481 return 0;
7fd59977 2482}
2483
2484#include <math.h>
2485#include <gp_Pnt.hxx>
2486#include <Graphic3d_ArrayOfPoints.hxx>
2487#include <Graphic3d_ArrayOfPrimitives.hxx>
7fd59977 2488#include <Graphic3d_ArrayOfTriangles.hxx>
2489#include <Poly_Array1OfTriangle.hxx>
2490#include <Poly_Triangle.hxx>
2491#include <Poly_Triangulation.hxx>
2492#include <TColgp_Array1OfPnt.hxx>
2493#include <TShort_Array1OfShortReal.hxx>
2494#include <TShort_HArray1OfShortReal.hxx>
2495
2496#include <AIS_Triangulation.hxx>
2497#include <Aspect_GraphicDevice.hxx>
2498#include <StdPrs_ToolShadedShape.hxx>
2499#include <Poly_Connect.hxx>
2500#include <TColgp_Array1OfDir.hxx>
2501#include <Graphic3d_GraphicDriver.hxx>
2502
7fd59977 2503#include <TColStd_Array1OfInteger.hxx>
2504#include <TColStd_HArray1OfInteger.hxx>
2505#include <Prs3d_ShadingAspect.hxx>
2506#include <Graphic3d_MaterialAspect.hxx>
2507#include <Graphic3d_AspectFillArea3d.hxx>
2508
2509#include <BRepPrimAPI_MakeCylinder.hxx>
2510#include <TopoDS_Shape.hxx>
2511#include <TopExp_Explorer.hxx>
2512#include <TopAbs.hxx>
2513#include <StdSelect_ShapeTypeFilter.hxx>
2514
2515
2516//===============================================================================================
2517//function : CalculationOfSphere
2518//author : psn
2519//purpose : Create a Sphere
2520//===============================================================================================
2521
161c4476 2522Handle( Poly_Triangulation ) CalculationOfSphere( double X , double Y , double Z ,
7fd59977 2523 int res ,
2524 double Radius ){
2525 double mRadius = Radius;
2526 double mCenter[3] = {X,Y,Z};
2527 int mThetaResolution;
2528 int mPhiResolution;
2529 double mStartTheta = 0;//StartTheta;
2530 double mEndTheta = 360;//EndTheta;
2531 double mStartPhi = 0;//StartPhi;
2532 double mEndPhi = 180;//EndPhi;
2533 res = res < 4 ? 4 : res;
2534
2535 mThetaResolution = res;
2536 mPhiResolution = res;
2537
2538 int i, j;
2539 int jStart, jEnd, numOffset;
2540 int numPts, numPolys;
2541 double x[3], n[3], deltaPhi, deltaTheta, phi, theta, radius;
2542 double startTheta, endTheta, startPhi, endPhi;
2543 int base, numPoles=0, thetaResolution, phiResolution;
2544
2545 int pts[3];
2546 int piece = -1;
2547 int numPieces = 1;
2548 if ( numPieces > mThetaResolution ) {
2549 numPieces = mThetaResolution;
2550 }
2551
2552 int localThetaResolution = mThetaResolution;
2553 double localStartTheta = mStartTheta;
2554 double localEndTheta = mEndTheta;
2555
2556 while ( localEndTheta < localStartTheta ) {
2557 localEndTheta += 360.0;
2558 }
2559
2560 deltaTheta = (localEndTheta - localStartTheta) / localThetaResolution;
2561
2562 // Change the ivars based on pieces.
2563 int start, end;
2564 start = piece * localThetaResolution / numPieces;
2565 end = (piece+1) * localThetaResolution / numPieces;
2566 localEndTheta = localStartTheta + (double)(end) * deltaTheta;
2567 localStartTheta = localStartTheta + (double)(start) * deltaTheta;
2568 localThetaResolution = end - start;
2569
2570 numPts = mPhiResolution * localThetaResolution + 2;
2571 numPolys = mPhiResolution * 2 * localThetaResolution;
2572
2573 // Create north pole if needed
2574 int number_point = 0;
2575 int number_pointArray = 0;
2576
2577 if ( mStartPhi <= 0.0 ) {
2578 number_pointArray++;
2579 numPoles++;
2580 }
2581 if ( mEndPhi >= 180.0 ) {
2582 number_pointArray++;
2583 numPoles++;
2584 }
161c4476 2585
7fd59977 2586 // Check data, determine increments, and convert to radians
2587 startTheta = (localStartTheta < localEndTheta ? localStartTheta : localEndTheta);
c6541a0c 2588 startTheta *= M_PI / 180.0;
7fd59977 2589 endTheta = (localEndTheta > localStartTheta ? localEndTheta : localStartTheta);
c6541a0c 2590 endTheta *= M_PI / 180.0;
7fd59977 2591
2592
2593 startPhi = ( mStartPhi < mEndPhi ? mStartPhi : mEndPhi);
c6541a0c 2594 startPhi *= M_PI / 180.0;
7fd59977 2595 endPhi = ( mEndPhi > mStartPhi ? mEndPhi : mStartPhi);
c6541a0c 2596 endPhi *= M_PI / 180.0;
7fd59977 2597
2598 phiResolution = mPhiResolution - numPoles;
2599 deltaPhi = (endPhi - startPhi) / ( mPhiResolution - 1);
2600 thetaResolution = localThetaResolution;
2601 if ( fabs(localStartTheta - localEndTheta) < 360.0 ) {
2602 ++localThetaResolution;
2603 }
2604 deltaTheta = (endTheta - startTheta) / thetaResolution;
2605
2606 jStart = ( mStartPhi <= 0.0 ? 1 : 0);
2607 jEnd = ( mEndPhi >= 180.0 ? mPhiResolution - 1 : mPhiResolution);
2608
2609 // Create intermediate points
2610 for ( i = 0; i < localThetaResolution; i++ ) {
2611 for ( j = jStart; j < jEnd; j++ ) {
2612 number_pointArray++;
2613 }
2614 }
2615
2616 //Generate mesh connectivity
2617 base = phiResolution * localThetaResolution;
2618
2619 int number_triangle = 0 ;
2620 if ( mStartPhi <= 0.0 ) { // around north pole
2621 number_triangle += localThetaResolution;
2622 }
161c4476 2623
7fd59977 2624 if ( mEndPhi >= 180.0 ) { // around south pole
2625 number_triangle += localThetaResolution;
2626 }
2627
2628 // bands in-between poles
2629 for ( i=0; i < localThetaResolution; i++){
2630 for ( j=0; j < (phiResolution-1); j++){
2631 number_triangle +=2;
2632 }
2633 }
2634
2635 Handle( Poly_Triangulation ) polyTriangulation = new Poly_Triangulation(number_pointArray, number_triangle, false);
2636 TColgp_Array1OfPnt& PointsOfArray = polyTriangulation->ChangeNodes();
2637 Poly_Array1OfTriangle& pArrayTriangle = polyTriangulation->ChangeTriangles();
2638
2639 if ( mStartPhi <= 0.0 ){
2640 x[0] = mCenter[0];
2641 x[1] = mCenter[1];
2642 x[2] = mCenter[2] + mRadius;
2643 PointsOfArray.SetValue(1,gp_Pnt(x[0],x[1],x[2]));
2644 }
2645
2646 // Create south pole if needed
2647 if ( mEndPhi >= 180.0 ){
2648 x[0] = mCenter[0];
2649 x[1] = mCenter[1];
2650 x[2] = mCenter[2] - mRadius;
2651 PointsOfArray.SetValue(2,gp_Pnt(x[0],x[1],x[2]));
2652 }
2653
2654 number_point = 3;
2655 for ( i=0; i < localThetaResolution; i++){
c6541a0c 2656 theta = localStartTheta * M_PI / 180.0 + i*deltaTheta;
7fd59977 2657 for ( j = jStart; j < jEnd; j++){
2658 phi = startPhi + j*deltaPhi;
2659 radius = mRadius * sin((double)phi);
2660 n[0] = radius * cos((double)theta);
2661 n[1] = radius * sin((double)theta);
2662 n[2] = mRadius * cos((double)phi);
2663 x[0] = n[0] + mCenter[0];
2664 x[1] = n[1] + mCenter[1];
2665 x[2] = n[2] + mCenter[2];
2666 PointsOfArray.SetValue(number_point,gp_Pnt(x[0],x[1],x[2]));
2667 number_point++;
2668 }
2669 }
2670
2671 numPoles = 3;
2672 number_triangle = 1;
2673 if ( mStartPhi <= 0.0 ){// around north pole
2674 for (i=0; i < localThetaResolution; i++){
2675 pts[0] = phiResolution*i + numPoles;
2676 pts[1] = (phiResolution*(i+1) % base) + numPoles;
2677 pts[2] = 1;
2678 pArrayTriangle.SetValue(number_triangle,Poly_Triangle(pts[0],pts[1],pts[2]));
2679 number_triangle++;
2680 }
2681 }
161c4476 2682
7fd59977 2683 if ( mEndPhi >= 180.0 ){ // around south pole
2684 numOffset = phiResolution - 1 + numPoles;
2685 for (i=0; i < localThetaResolution; i++){
2686 pts[0] = phiResolution*i + numOffset;
2687 pts[2] = ((phiResolution*(i+1)) % base) + numOffset;
2688 pts[1] = numPoles - 1;
2689 pArrayTriangle.SetValue(number_triangle,Poly_Triangle(pts[0],pts[1],pts[2]));
2690 number_triangle++;
2691 }
2692 }
2693
2694 // bands in-between poles
161c4476 2695
7fd59977 2696 for (i=0; i < localThetaResolution; i++){
2697 for (j=0; j < (phiResolution-1); j++){
2698 pts[0] = phiResolution*i + j + numPoles;
2699 pts[1] = pts[0] + 1;
2700 pts[2] = ((phiResolution*(i+1)+j) % base) + numPoles + 1;
2701 pArrayTriangle.SetValue(number_triangle,Poly_Triangle(pts[0],pts[1],pts[2]));
2702 number_triangle++;
2703 pts[1] = pts[2];
2704 pts[2] = pts[1] - 1;
2705 pArrayTriangle.SetValue(number_triangle,Poly_Triangle(pts[0],pts[1],pts[2]));
2706 number_triangle++;
2707 }
2708 }
2709
2710 Poly_Connect* pc = new Poly_Connect(polyTriangulation);
2711
2712 Handle(TShort_HArray1OfShortReal) Normals = new TShort_HArray1OfShortReal(1, polyTriangulation->NbNodes() * 3);
2713
2714 Standard_Integer index[3];
2715 Standard_Real Tol = Precision::Confusion();
2716
2717 gp_Dir Nor;
2718 for (i = PointsOfArray.Lower(); i <= PointsOfArray.Upper(); i++) {
2719 gp_XYZ eqPlan(0, 0, 0);
2720 for ( pc->Initialize(i); pc->More(); pc->Next()) {
2721 pArrayTriangle(pc->Value()).Get(index[0], index[1], index[2]);
2722 gp_XYZ v1(PointsOfArray(index[1]).Coord()-PointsOfArray(index[0]).Coord());
2723 gp_XYZ v2(PointsOfArray(index[2]).Coord()-PointsOfArray(index[1]).Coord());
2724 gp_XYZ vv = v1^v2;
2725 Standard_Real mod = vv.Modulus();
2726 if(mod < Tol) continue;
2727 eqPlan += vv/mod;
2728 }
2729
2730 Standard_Real modmax = eqPlan.Modulus();
2731
161c4476 2732 if(modmax > Tol)
7fd59977 2733 Nor = gp_Dir(eqPlan);
161c4476 2734 else
7fd59977 2735 Nor = gp_Dir(0., 0., 1.);
2736
2737 Standard_Integer j = (i - PointsOfArray.Lower()) * 3;
2738 Normals->SetValue(j + 1, (Standard_ShortReal)Nor.X());
2739 Normals->SetValue(j + 2, (Standard_ShortReal)Nor.Y());
2740 Normals->SetValue(j + 3, (Standard_ShortReal)Nor.Z());
2741 }
2742
2743 delete pc;
2744 polyTriangulation->SetNormals(Normals);
2745
2746 return polyTriangulation;
2747}
2748
2749//===============================================================================================
2750//function : VDrawSphere
2751//author : psn
2752//purpose : Create an AIS shape.
7fd59977 2753//===============================================================================================
161c4476
K
2754static int VDrawSphere (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
2755{
2756 // check for errors
2757 Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext();
2758 if (aContextAIS.IsNull())
2759 {
2760 std::cout << "Call vinit before!\n";
2761 return 1;
2762 }
2763 else if (argc < 3)
2764 {
2765 std::cout << "Use: " << argv[0]
2766 << " shapeName Fineness [X=0.0 Y=0.0 Z=0.0] [Radius=100.0] [ToEnableVBO=1] [NumberOfViewerUpdate=1] [ToShowEdges=0]\n";
2767 return 1;
2768 }
7fd59977 2769
161c4476
K
2770 // read the arguments
2771 TCollection_AsciiString aShapeName (argv[1]);
2772 Standard_Integer aResolution = atoi (argv[2]);
2773 Standard_Real aCenterX = (argc > 5) ? atof (argv[3]) : 0.0;
2774 Standard_Real aCenterY = (argc > 5) ? atof (argv[4]) : 0.0;
2775 Standard_Real aCenterZ = (argc > 5) ? atof (argv[5]) : 0.0;
2776 Standard_Real aRadius = (argc > 6) ? atof (argv[6]) : 100.0;
208e6839 2777 Standard_Boolean toShowEdges = (argc > 7) ? atoi (argv[7]) : Standard_False;
7fd59977 2778
161c4476 2779 // remove AIS object with given name from map
208e6839 2780 VDisplayAISObject (aShapeName, Handle(AIS_InteractiveObject)());
161c4476
K
2781
2782 std::cout << "Compute Triangulation...\n";
2783 Handle(AIS_Triangulation) aShape
2784 = new AIS_Triangulation (CalculationOfSphere (aCenterX, aCenterY, aCenterZ,
2785 aResolution,
2786 aRadius));
2787 Standard_Integer aNumberPoints = aShape->GetTriangulation()->Nodes().Length();
2788 Standard_Integer aNumberTriangles = aShape->GetTriangulation()->Triangles().Length();
2789
161c4476
K
2790 // stupid initialization of Green color in RGBA space as integer
2791 // probably wrong for big-endian CPUs
2792 Standard_Integer aRed = 0;
2793 Standard_Integer aGreen = 255;
2794 Standard_Integer aBlue = 0;
2795 Standard_Integer anAlpha = 0; // not used
2796 Standard_Integer aColorInt = aRed;
2797 aColorInt += aGreen << 8;
2798 aColorInt += aBlue << 16;
2799 aColorInt += anAlpha << 24;
2800
2801 // setup colors array per vertex
2802 Handle(TColStd_HArray1OfInteger) aColorArray = new TColStd_HArray1OfInteger (1, aNumberPoints);
2803 for (Standard_Integer aNodeId = 1; aNodeId <= aNumberPoints; ++aNodeId)
2804 {
2805 aColorArray->SetValue (aNodeId, aColorInt);
7fd59977 2806 }
161c4476
K
2807 aShape->SetColors (aColorArray);
2808
2809 // show statistics
2810 Standard_Integer aPointsSize = aNumberPoints * 3 * sizeof(float); // 3x GLfloat
2811 Standard_Integer aNormalsSize = aNumberPoints * 3 * sizeof(float); // 3x GLfloat
2812 Standard_Integer aColorsSize = aNumberPoints * 3 * sizeof(float); // 3x GLfloat without alpha
2813 Standard_Integer aTrianglesSize = aNumberTriangles * 3 * sizeof(int); // 3x GLint
2814 Standard_Integer aPolyConnectSize = aNumberPoints * 4 + aNumberTriangles * 6 * 4;
2815 Standard_Integer aTotalSize = aPointsSize + aNormalsSize + aColorsSize + aTrianglesSize;
2816 aTotalSize >>= 20; //MB
2817 aNormalsSize >>= 20;
2818 aColorsSize >>= 20;
2819 aTrianglesSize >>= 20;
2820 aPolyConnectSize >>= 20;
2821 std::cout << "NumberOfPoints: " << aNumberPoints << "\n"
2822 << "NumberOfTriangles: " << aNumberTriangles << "\n"
2823 << "Amount of memory required for PolyTriangulation without Normals: " << (aTotalSize - aNormalsSize) << " Mb\n"
2824 << "Amount of memory for colors: " << aColorsSize << " Mb\n"
2825 << "Amount of memory for PolyConnect: " << aPolyConnectSize << " Mb\n"
2826 << "Amount of graphic card memory required: " << aTotalSize << " Mb\n";
7fd59977 2827
2828 // Setting material properties, very important for desirable visual result!
161c4476
K
2829 Graphic3d_MaterialAspect aMat (Graphic3d_NOM_PLASTIC);
2830 aMat.SetAmbient (0.2);
2831 aMat.SetSpecular (0.5);
2832 Handle(Graphic3d_AspectFillArea3d) anAspect
2833 = new Graphic3d_AspectFillArea3d (Aspect_IS_SOLID,
2834 Quantity_NOC_RED,
2835 Quantity_NOC_YELLOW,
2836 Aspect_TOL_SOLID,
2837 1.0,
2838 aMat,
2839 aMat);
7fd59977 2840 Handle(Prs3d_ShadingAspect) aShAsp = new Prs3d_ShadingAspect();
161c4476
K
2841 if (toShowEdges)
2842 {
2843 anAspect->SetEdgeOn();
2844 }
7fd59977 2845 else
161c4476
K
2846 {
2847 anAspect->SetEdgeOff();
2848 }
2849 aShAsp->SetAspect (anAspect);
2850 aShape->Attributes()->SetShadingAspect (aShAsp);
7fd59977 2851
208e6839 2852 VDisplayAISObject (aShapeName, aShape);
7fd59977 2853 return 0;
2854}
2855
4952a30a 2856//===============================================================================================
2857//function : VClipPlane
2858//purpose :
2859//===============================================================================================
2860static int VClipPlane (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
2861{
2862 Handle(V3d_Viewer) aViewer = ViewerTest::GetViewerFromContext();
2863 Handle(V3d_View) aView = ViewerTest::CurrentView();
2864 Standard_Real coeffA, coeffB, coeffC, coeffD;
2865 if (aViewer.IsNull() || aView.IsNull())
2866 {
2867 std::cout << "Viewer not initialized!\n";
2868 return 1;
2869 }
2870
2871 // count an active planes count
2872 Standard_Integer aNewPlaneId = 1;
2873 Standard_Integer anActivePlanes = 0;
2874 for (aViewer->InitDefinedPlanes(); aViewer->MoreDefinedPlanes(); aViewer->NextDefinedPlanes(), ++aNewPlaneId)
2875 {
2876 Handle(V3d_Plane) aPlaneV3d = aViewer->DefinedPlane();
2877 if (aView->IsActivePlane (aPlaneV3d))
2878 {
2879 ++anActivePlanes;
2880 }
2881 }
2882
2883 if (argc == 1)
2884 {
2885 // just show info about existing planes
2886 Standard_Integer aPlaneId = 1;
2887 std::cout << "Active planes: " << anActivePlanes << " from maximal " << aView->View()->PlaneLimit() << "\n";
2888 for (aViewer->InitDefinedPlanes(); aViewer->MoreDefinedPlanes(); aViewer->NextDefinedPlanes(), ++aPlaneId)
2889 {
2890 Handle(V3d_Plane) aPlaneV3d = aViewer->DefinedPlane();
2891 aPlaneV3d->Plane (coeffA, coeffB, coeffC, coeffD);
2892 gp_Pln aPlane (coeffA, coeffB, coeffC, coeffD);
2893 const gp_Pnt& aLoc = aPlane.Location();
2894 const gp_Dir& aNor = aPlane.Axis().Direction();
2895 Standard_Boolean isActive = aView->IsActivePlane (aPlaneV3d);
2896 std::cout << "Plane #" << aPlaneId
2897 << " " << aLoc.X() << " " << aLoc.Y() << " " << aLoc.Z()
2898 << " " << aNor.X() << " " << aNor.Y() << " " << aNor.Z()
2899 << (isActive ? " on" : " off")
2900 << (aPlaneV3d->IsDisplayed() ? ", displayed" : ", hidden")
2901 << "\n";
2902 }
2903 if (aPlaneId == 1)
2904 {
2905 std::cout << "No defined clipping planes\n";
2906 }
2907 return 0;
2908 }
2909 else if (argc == 2 || argc == 3)
2910 {
2911 Standard_Integer aPlaneIdToOff = (argc == 3) ? atoi (argv[1]) : 1;
2912 Standard_Boolean toIterateAll = (argc == 2);
2913 TCollection_AsciiString isOnOffStr ((argc == 3) ? argv[2] : argv[1]);
2914 isOnOffStr.LowerCase();
2915 Standard_Integer aPlaneId = 1;
2916 for (aViewer->InitDefinedPlanes(); aViewer->MoreDefinedPlanes(); aViewer->NextDefinedPlanes(), ++aPlaneId)
2917 {
2918 if (aPlaneIdToOff == aPlaneId || toIterateAll)
2919 {
2920 Handle(V3d_Plane) aPlaneV3d = aViewer->DefinedPlane();
2921 if (isOnOffStr.Search ("off") >= 0)
2922 {
2923 aView->SetPlaneOff (aPlaneV3d);
2924 std::cout << "Clipping plane #" << aPlaneId << " was disabled\n";
2925 }
2926 else if (isOnOffStr.Search ("on") >= 0)
2927 {
2928 // avoid z-fighting glitches
2929 aPlaneV3d->Erase();
2930 if (!aView->IsActivePlane (aPlaneV3d))
2931 {
2932 if (anActivePlanes < aView->View()->PlaneLimit())
2933 {
2934 aView->SetPlaneOn (aPlaneV3d);
2935 std::cout << "Clipping plane #" << aPlaneId << " was enabled\n";
2936 }
2937 else
2938 {
2939 std::cout << "Maximal active planes limit exceeded (" << anActivePlanes << ")\n"
2940 << "You should disable or remove some existing plane to activate this one\n";
2941 }
2942 }
2943 else
2944 {
2945 std::cout << "Clipping plane #" << aPlaneId << " was already enabled\n";
2946 }
2947 }
2948 else if (isOnOffStr.Search ("del") >= 0 || isOnOffStr.Search ("rem") >= 0)
2949 {
2950 aPlaneV3d->Erase(); // not performed on destructor!!!
2951 aView->SetPlaneOff (aPlaneV3d);
2952 aViewer->DelPlane (aPlaneV3d);
2953 std::cout << "Clipping plane #" << aPlaneId << " was removed\n";
2954 if (toIterateAll)
2955 {
2956 for (aViewer->InitDefinedPlanes(); aViewer->MoreDefinedPlanes(); aViewer->InitDefinedPlanes(), ++aPlaneId)
2957 {
2958 aPlaneV3d = aViewer->DefinedPlane();
2959 aPlaneV3d->Erase(); // not performed on destructor!!!
2960 aView->SetPlaneOff (aPlaneV3d);
2961 aViewer->DelPlane (aPlaneV3d);
2962 std::cout << "Clipping plane #" << aPlaneId << " was removed\n";
2963 }
2964 break;
2965 }
2966 else
2967 {
2968 break;
2969 }
2970 }
2971 else if (isOnOffStr.Search ("disp") >= 0 || isOnOffStr.Search ("show") >= 0)
2972 {
2973 // avoid z-fighting glitches
2974 aView->SetPlaneOff (aPlaneV3d);
2975 aPlaneV3d->Display (aView);
2976 std::cout << "Clipping plane #" << aPlaneId << " was shown and disabled\n";
2977 }
2978 else if (isOnOffStr.Search ("hide") >= 0)
2979 {
2980 aPlaneV3d->Erase();
2981 std::cout << "Clipping plane #" << aPlaneId << " was hidden\n";
2982 }
2983 else
2984 {
2985 std::cout << "Usage: " << argv[0] << " [x y z dx dy dz] [planeId {on/off/del/display/hide}]\n";
2986 return 1;
2987 }
2988 }
2989 }
2990 if (aPlaneIdToOff >= aPlaneId && !toIterateAll)
2991 {
2992 std::cout << "Clipping plane with id " << aPlaneIdToOff << " not found!\n";
2993 return 1;
2994 }
2995 aView->Update();
2996 return 0;
2997 }
2998 else if (argc != 7)
2999 {
3000 std::cout << "Usage: " << argv[0] << " [x y z dx dy dz] [planeId {on/off/del/display/hide}]\n";
3001 return 1;
3002 }
3003
3004 Standard_Real aLocX = atof (argv[1]);
3005 Standard_Real aLocY = atof (argv[2]);
3006 Standard_Real aLocZ = atof (argv[3]);
3007 Standard_Real aNormDX = atof (argv[4]);
3008 Standard_Real aNormDY = atof (argv[5]);
3009 Standard_Real aNormDZ = atof (argv[6]);
3010
3011 Handle(V3d_Plane) aPlaneV3d = new V3d_Plane();
3012 gp_Pln aPlane (gp_Pnt (aLocX, aLocY, aLocZ), gp_Dir (aNormDX, aNormDY, aNormDZ));
3013 aPlane.Coefficients (coeffA, coeffB, coeffC, coeffD);
3014 aPlaneV3d->SetPlane(coeffA, coeffB, coeffC, coeffD);
3015
3016 aViewer->AddPlane (aPlaneV3d); // add to defined planes list
3017 std::cout << "Added clipping plane #" << aNewPlaneId << "\n";
3018 if (anActivePlanes < aView->View()->PlaneLimit())
3019 {
3020 aView->SetPlaneOn (aPlaneV3d); // add to enabled planes list
13a22457 3021 aView->Update();
4952a30a 3022 }
3023 else
3024 {
3025 std::cout << "Maximal active planes limit exceeded (" << anActivePlanes << ")\n"
3026 << "You should disable or remove some existing plane to activate the new one\n";
3027 }
3028 return 0;
3029}
7fd59977 3030
3fc57801 3031//=============================================================================
3032//function : VComputeHLR
3033//purpose :
3034//=============================================================================
3035
3036static int VComputeHLR (Draw_Interpretor& di,
3037 Standard_Integer argc,
3038 const char** argv)
3039{
3040 Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext ();
3041
3042 if (aContextAIS.IsNull ())
3043 {
3044 di << "Please call vinit before\n";
3045 return 1;
3046 }
3047
3048 if ( argc != 3 && argc != 12 )
3049 {
3050 di << "Usage: " << argv[0] << " ShapeName HlrName "
3051 << "[ eye_x eye_y eye_z dir_x dir_y dir_z upx upy upz ]" << "\n"
3052 << " ShapeName - name of the initial shape\n"
3053 << " HlrName - result hlr object from initial shape\n"
3054 << " eye, dir are eye position and look direction\n"
3055 << " up is the look up direction vector\n"
3056 << " Use vtop to see projected hlr shape\n";
3057 return 1;
3058 }
3059
3060 // shape and new object name
3061 TCollection_AsciiString aShapeName (argv[1]);
3062 TCollection_AsciiString aHlrName (argv[2]);
3063
3064 TopoDS_Shape aSh = DBRep::Get (argv[1]);
3065 if (aSh.IsNull())
3066 {
3067 BRep_Builder aBrepBuilder;
3068 BRepTools::Read (aSh, argv[1], aBrepBuilder);
3069 if (aSh.IsNull ())
3070 {
3071 di << "No shape with name " << argv[1] << " found\n";
3072 return 1;
3073 }
3074 }
3075
3076 if (GetMapOfAIS ().IsBound2 (aHlrName))
3077 {
3078 di << "Presentable object with name " << argv[2] << " already exists\n";
3079 return 1;
3080 }
3081
3082 // close local context
3083 if (aContextAIS->HasOpenedContext ())
3084 aContextAIS->CloseLocalContext ();
3085
3086 Handle(HLRBRep_PolyAlgo) aPolyAlgo = new HLRBRep_PolyAlgo();
3087 HLRBRep_PolyHLRToShape aHLRToShape;
3088
3089 gp_Pnt anEye;
3090 gp_Dir aDir;
3091 gp_Ax2 aProjAx;
3092 if (argc == 9)
3093 {
3094 gp_Dir anUp;
3095
3096 anEye.SetCoord (atof (argv[3]), atof (argv[4]), atof (argv[5]));
3097 aDir.SetCoord (atof (argv[6]), atof (argv[7]), atof (argv[8]));
3098 anUp.SetCoord (atof (argv[9]), atof (argv[10]), atof (argv[11]));
3099 aProjAx.SetLocation (anEye);
3100 aProjAx.SetDirection (aDir);
3101 aProjAx.SetYDirection (anUp);
3102 }
3103 else
3104 {
3105 gp_Dir aRight;
3106
3107 Handle(V3d_Viewer) aViewer = ViewerTest::GetViewerFromContext();
3108 Handle(V3d_View) aView = ViewerTest::CurrentView();
3109 Standard_Integer aWidth, aHeight;
3110 Standard_Real aCentX, aCentY, aCentZ, aDirX, aDirY, aDirZ;
3111 Standard_Real aRightX, aRightY, aRightZ;
3112 aView->Window()->Size (aWidth, aHeight);
3113
3114 aView->ConvertWithProj (aWidth, aHeight/2,
3115 aRightX, aRightY, aRightZ,
3116 aDirX, aDirY, aDirZ);
3117
3118 aView->ConvertWithProj (aWidth/2, aHeight/2,
3119 aCentX, aCentY, aCentZ,
3120 aDirX, aDirY, aDirZ);
3121
3122 anEye.SetCoord (-aCentX, -aCentY, -aCentZ);
3123 aDir.SetCoord (-aDirX, -aDirY, -aDirZ);
3124 aRight.SetCoord (aRightX - aCentX, aRightY - aCentY, aRightZ - aCentZ);
3125 aProjAx.SetLocation (anEye);
3126 aProjAx.SetDirection (aDir);
3127 aProjAx.SetXDirection (aRight);
3128 }
3129
3130 HLRAlgo_Projector aProjector (aProjAx);
3131 aPolyAlgo->Projector (aProjector);
3132 aPolyAlgo->Load (aSh);
3133 aPolyAlgo->Update ();
3134
3135 aHLRToShape.Update (aPolyAlgo);
3136
3137 // make hlr shape from input shape
3138 TopoDS_Compound aHlrShape;
3139 BRep_Builder aBuilder;
3140 aBuilder.MakeCompound (aHlrShape);
3141
3142 TopoDS_Shape aCompound = aHLRToShape.VCompound();
3143 if (!aCompound.IsNull ())
3144 {
3145 aBuilder.Add (aHlrShape, aCompound);
3146 }
3147
3148 // extract visible outlines
3149 aCompound = aHLRToShape.OutLineVCompound();
3150 if (!aCompound.IsNull ())
3151 {
3152 aBuilder.Add (aHlrShape, aCompound);
3153 }
3154
3155 // create an AIS shape and display it
3156 Handle(AIS_Shape) anObject = new AIS_Shape (aHlrShape);
3157 GetMapOfAIS().Bind (anObject, aHlrName);
3158 aContextAIS->Display (anObject);
3159
3160 aContextAIS->UpdateCurrentViewer ();
3161
3162 return 0;
3163}
3164
9558a876
A
3165// This class is a wrap for Graphic3d_ArrayOfPrimitives; it is used for
3166// manipulating and displaying such an array with AIS context
3167DEFINE_STANDARD_HANDLE(MyPArrayObject, AIS_InteractiveObject)
3168class MyPArrayObject : public AIS_InteractiveObject
3169{
3170
3171public:
3172
3173 MyPArrayObject (const Handle(Graphic3d_ArrayOfPrimitives) theArray)
3174 {
3175 myArray = theArray;
3176 }
3177
3178 DEFINE_STANDARD_RTTI(MyPArrayObject);
3179
3180private:
3181
3182 void Compute (const Handle(PrsMgr_PresentationManager3d)& aPresentationManager,
3183 const Handle(Prs3d_Presentation)& aPresentation,
3184 const Standard_Integer aMode);
3185
3186 void ComputeSelection (const Handle(SelectMgr_Selection)& aSelection,
3187 const Standard_Integer aMode) {};
3188
3189protected:
3190
3191 Handle(Graphic3d_ArrayOfPrimitives) myArray;
3192
3193};
3194
3195IMPLEMENT_STANDARD_HANDLE(MyPArrayObject, AIS_InteractiveObject)
3196IMPLEMENT_STANDARD_RTTIEXT(MyPArrayObject, AIS_InteractiveObject)
3197
3198void MyPArrayObject::Compute (const Handle(PrsMgr_PresentationManager3d)& aPresentationManager,
3199 const Handle(Prs3d_Presentation)& aPresentation,
3200 const Standard_Integer aMode)
3201{
3202 aPresentation->Clear();
b8ddfc2f 3203 Prs3d_Root::CurrentGroup (aPresentation)->AddPrimitiveArray (myArray);
9558a876
A
3204}
3205
3206static bool CheckInputCommand (const TCollection_AsciiString theCommand,
3207 const char **theArgStr, int &theArgIndex,
3208 int theArgCount, int theMaxArgs)
3209{
3210 // check if there is more elements than expected
3211 if (theArgIndex >= theMaxArgs)
3212 return false;
3213
3214 TCollection_AsciiString aStrCommand(theArgStr[theArgIndex]);
3215 aStrCommand.LowerCase();
3216 if (aStrCommand.Search(theCommand) != 1 ||
3217 theArgIndex + (theArgCount - 1) >= theMaxArgs)
3218 return false;
3219
3220 // go to the first data element
3221 theArgIndex++;
3222
3223 // check data if it can be converted to numeric
3224 for (int aElement = 0; aElement < theArgCount; aElement++, theArgIndex++)
3225 {
3226 aStrCommand = theArgStr[theArgIndex];
3227 if (!aStrCommand.IsRealValue())
3228 return false;
3229 }
3230
3231 return true;
3232}
3233
3234//=============================================================================
3235//function : VDrawPArray
3236//purpose : Draws primitives array from list of vertexes, bounds, edges
3237//=============================================================================
3238
3239static int VDrawPArray (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
3240{
3241 Handle(AIS_InteractiveContext) aContextAIS = ViewerTest::GetAISContext();
3242 if (aContextAIS.IsNull())
3243 {
3244 di << "Call vinit before!\n";
3245 return 1;
3246 }
3247 else if (argc < 3)
3248 {
5e27df78 3249 di << "Use: " << argv[0] << " Name TypeOfArray"
9558a876
A
3250 << " [vertex] ... [bounds] ... [edges]\n"
3251 << " TypeOfArray={ points | segments | polylines | triangles |\n"
5e27df78 3252 << " trianglefans | trianglestrips | quads |\n"
9558a876
A
3253 << " quadstrips | polygons }\n"
3254 << " vertex={ 'v' x y z [normal={ 'n' nx ny nz }] [color={ 'c' r g b }]"
3255 << " [texel={ 't' tx ty }] } \n"
3256 << " bounds={ 'b' verticies_count [color={ 'c' r g b }] }\n"
3257 << " edges={ 'e' vertex_id [hidden_edge={'h'}] }\n";