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