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