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