0027905: Visualization - randomly directed arrows on test v3d mesh B7
[occt.git] / src / XSDRAWSTLVRML / XSDRAWSTLVRML.cxx
1 // Created on: 2000-05-30
2 // Created by: Sergey MOZOKHIN
3 // Copyright (c) 2000-2014 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and/or modify it under
8 // the terms of the GNU Lesser General Public License version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16
17 #include <AIS_InteractiveContext.hxx>
18 #include <Aspect_TypeOfMarker.hxx>
19 #include <Bnd_Box.hxx>
20 #include <DBRep.hxx>
21 #include <Draw.hxx>
22 #include <Draw_Interpretor.hxx>
23 #include <Draw_PluginMacro.hxx>
24 #include <Draw_ProgressIndicator.hxx>
25 #include <Graphic3d_MaterialAspect.hxx>
26 #include <MeshVS_DataMapOfIntegerAsciiString.hxx>
27 #include <MeshVS_DeformedDataSource.hxx>
28 #include <MeshVS_Drawer.hxx>
29 #include <MeshVS_DrawerAttribute.hxx>
30 #include <MeshVS_ElementalColorPrsBuilder.hxx>
31 #include <MeshVS_Mesh.hxx>
32 #include <MeshVS_MeshEntityOwner.hxx>
33 #include <MeshVS_MeshPrsBuilder.hxx>
34 #include <MeshVS_NodalColorPrsBuilder.hxx>
35 #include <MeshVS_PrsBuilder.hxx>
36 #include <MeshVS_TextPrsBuilder.hxx>
37 #include <MeshVS_VectorPrsBuilder.hxx>
38 #include <OSD_Path.hxx>
39 #include <Quantity_Color.hxx>
40 #include <Quantity_HArray1OfColor.hxx>
41 #include <Quantity_NameOfColor.hxx>
42 #include <RWStl.hxx>
43 #include <SelectMgr_SelectionManager.hxx>
44 #include <Standard_ErrorHandler.hxx>
45 #include <StdSelect_ViewerSelector3d.hxx>
46 #include <StlAPI.hxx>
47 #include <StlAPI_Writer.hxx>
48 #include <StlMesh_Mesh.hxx>
49 #include <StlMesh_SequenceOfMeshTriangle.hxx>
50 #include <TColgp_SequenceOfXYZ.hxx>
51 #include <TCollection_AsciiString.hxx>
52 #include <TColStd_Array1OfReal.hxx>
53 #include <TColStd_HPackedMapOfInteger.hxx>
54 #include <TColStd_MapIteratorOfPackedMapOfInteger.hxx>
55 #include <TopoDS_Shape.hxx>
56 #include <V3d_View.hxx>
57 #include <ViewerTest.hxx>
58 #include <VrmlAPI.hxx>
59 #include <VrmlAPI_Writer.hxx>
60 #include <VrmlData_DataMapOfShapeAppearance.hxx>
61 #include <VrmlData_Scene.hxx>
62 #include <VrmlData_ShapeConvert.hxx>
63 #include <XSDRAW.hxx>
64 #include <XSDRAWIGES.hxx>
65 #include <XSDRAWSTEP.hxx>
66 #include <XSDRAWSTLVRML.hxx>
67 #include <XSDRAWSTLVRML_DataSource.hxx>
68 #include <XSDRAWSTLVRML_DataSource3D.hxx>
69 #include <XSDRAWSTLVRML_DrawableMesh.hxx>
70
71 // avoid warnings on 'extern "C"' functions returning C++ classes
72 #ifdef _MSC_VER
73 #pragma warning(4:4190)
74 #endif
75
76 #ifndef _STDIO_H
77 #include <stdio.h>
78 #endif
79
80 extern Standard_Boolean VDisplayAISObject (const TCollection_AsciiString& theName,
81                                            const Handle(AIS_InteractiveObject)& theAISObj,
82                                            Standard_Boolean theReplaceIfExists = Standard_True);
83
84 static Standard_Integer writestl
85 (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
86 {
87   if (argc < 3 || argc > 4) {
88     di << "Use: " << argv[0]
89     << " shape file [ascii/binary (0/1) : 1 by default]\n";
90   } else {
91     TopoDS_Shape aShape = DBRep::Get(argv[1]);
92     Standard_Boolean isASCIIMode = Standard_False;
93     if (argc == 4) {
94       isASCIIMode = (Draw::Atoi(argv[3]) == 0);
95     }
96     StlAPI_Writer aWriter;
97     aWriter.ASCIIMode() = isASCIIMode;
98     StlAPI_ErrorStatus aStatus = aWriter.Write (aShape, argv[2]);
99
100     switch (aStatus)
101     {
102     case StlAPI_MeshIsEmpty: di << "** Error **: Mesh is empty. Please, compute triangulation before."; break;
103     case StlAPI_CannotOpenFile: di << "** Error **: Cannot create/open a file with the passed name."; break;
104     case StlAPI_StatusOK: default: break;
105     }
106   }
107   return 0;
108 }
109
110 static Standard_Integer readstl
111 (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
112 {
113   if (argc<3) di << "wrong number of parameters"    << "\n";
114   else {
115     TopoDS_Shape aShape ;
116     StlAPI::Read(aShape,argv[2]);
117     DBRep::Set(argv[1],aShape);
118   }
119   return 0;
120 }
121
122 static Standard_Integer writevrml
123 (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
124 {
125   if (argc < 3 || argc > 5) 
126   {
127     di << "wrong number of parameters\n";
128     return 0;
129   }
130
131   TopoDS_Shape aShape = DBRep::Get(argv[1]);
132
133   // Get the optional parameters
134   Standard_Integer aVersion = 2;
135   Standard_Integer aType = 1;
136   if (argc >= 4)
137   {
138     aVersion = Draw::Atoi(argv[3]);
139     if (argc == 5)
140       aType = Draw::Atoi(argv[4]);
141   }
142
143   // Bound parameters
144   aVersion = Max(1, aVersion);
145   aVersion = Min(2, aVersion);
146   aType = Max(0, aType);
147   aType = Min(2, aType);
148
149   VrmlAPI_Writer writer;
150
151   switch (aType)
152   {
153   case 0: writer.SetRepresentation(VrmlAPI_ShadedRepresentation); break;
154   case 1: writer.SetRepresentation(VrmlAPI_WireFrameRepresentation); break;
155   case 2: writer.SetRepresentation(VrmlAPI_BothRepresentation); break;
156   }
157
158   writer.Write(aShape, argv[2], aVersion);
159
160   return 0;
161 }
162
163 //=======================================================================
164 //function : loadvrml
165 //purpose  :
166 //=======================================================================
167
168 static Standard_Integer loadvrml
169 (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
170 {
171   if (argc<3) di << "wrong number of parameters"    << "\n";
172   else {
173     TopoDS_Shape aShape ;
174     VrmlData_DataMapOfShapeAppearance aShapeAppMap;
175
176     //-----------------------------------------------------------
177     filebuf aFic;
178     istream aStream (&aFic);
179
180     if (aFic.open(argv[2], ios::in)) {
181
182       // Get path of the VRML file.
183       OSD_Path aPath(argv[2]);
184       TCollection_AsciiString aVrmlDir(".");
185       TCollection_AsciiString aDisk = aPath.Disk();
186       TCollection_AsciiString aTrek = aPath.Trek();
187       if (!aTrek.IsEmpty())
188       {
189         if (!aDisk.IsEmpty())
190           aVrmlDir = aDisk;
191         else
192           aVrmlDir.Clear();
193         aTrek.ChangeAll('|', '/');
194         aVrmlDir += aTrek;
195       }
196
197       VrmlData_Scene aScene;
198
199       aScene.SetVrmlDir (aVrmlDir);
200       aScene << aStream;
201       const char * aStr = 0L;
202       switch (aScene.Status()) {
203
204       case VrmlData_StatusOK:
205         {
206           aShape = aScene.GetShape(aShapeAppMap);
207           break;
208         }
209       case VrmlData_EmptyData:            aStr = "EmptyData"; break;
210       case VrmlData_UnrecoverableError:   aStr = "UnrecoverableError"; break;
211       case VrmlData_GeneralError:         aStr = "GeneralError"; break;
212       case VrmlData_EndOfFile:            aStr = "EndOfFile"; break;
213       case VrmlData_NotVrmlFile:          aStr = "NotVrmlFile"; break;
214       case VrmlData_CannotOpenFile:       aStr = "CannotOpenFile"; break;
215       case VrmlData_VrmlFormatError:      aStr = "VrmlFormatError"; break;
216       case VrmlData_NumericInputError:    aStr = "NumericInputError"; break;
217       case VrmlData_IrrelevantNumber:     aStr = "IrrelevantNumber"; break;
218       case VrmlData_BooleanInputError:    aStr = "BooleanInputError"; break;
219       case VrmlData_StringInputError:     aStr = "StringInputError"; break;
220       case VrmlData_NodeNameUnknown:      aStr = "NodeNameUnknown"; break;
221       case VrmlData_NonPositiveSize:      aStr = "NonPositiveSize"; break;
222       case VrmlData_ReadUnknownNode:      aStr = "ReadUnknownNode"; break;
223       case VrmlData_NonSupportedFeature:  aStr = "NonSupportedFeature"; break;
224       case VrmlData_OutputStreamUndefined:aStr = "OutputStreamUndefined"; break;
225       case VrmlData_NotImplemented:       aStr = "NotImplemented"; break;
226       default:
227         break;
228       }
229       if (aStr) {
230         di << " ++ VRML Error: " << aStr << " in line "
231           << aScene.GetLineError() << "\n";
232       }
233       else {
234         DBRep::Set(argv[1],aShape);
235       }
236     }
237     else {
238       di << "cannot open file\n";
239     }
240
241
242     //-----------------------------------------------------------
243   }
244   return 0;
245 }
246
247 //-----------------------------------------------------------------------------
248 static Standard_Integer createmesh
249 (Draw_Interpretor& di, Standard_Integer argc, const char** argv )
250 {
251   if (argc<3)
252   {
253     di << "Wrong number of parameters\n";
254     di << "Use: " << argv[0] << " <mesh name> <stl file>\n";
255     return 0;
256   }
257
258   Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
259   if (aContext.IsNull())
260   {
261     di << "No active view. Please call 'vinit' first\n";
262     return 0;
263   }
264
265   // Progress indicator
266   OSD_Path aFile( argv[2] );
267   Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator (di, 1);
268   Handle(StlMesh_Mesh) aSTLMesh = RWStl::ReadFile (aFile, aProgress);
269
270   di << "Reading OK...\n";
271   Handle( XSDRAWSTLVRML_DataSource ) aDS = new XSDRAWSTLVRML_DataSource( aSTLMesh );
272   di << "Data source is created successful\n";
273   Handle( MeshVS_Mesh ) aMesh = new MeshVS_Mesh();
274   di << "MeshVS_Mesh is created successful\n";
275
276   aMesh->SetDataSource( aDS );
277   aMesh->AddBuilder( new MeshVS_MeshPrsBuilder( aMesh.operator->() ), Standard_True );
278
279   aMesh->GetDrawer()->SetColor( MeshVS_DA_EdgeColor, Quantity_NOC_YELLOW );
280
281   // Hide all nodes by default
282   Handle(TColStd_HPackedMapOfInteger) aNodes = new TColStd_HPackedMapOfInteger();
283   Standard_Integer aLen = aSTLMesh->Vertices().Length();
284   for ( Standard_Integer anIndex = 1; anIndex <= aLen; anIndex++ )
285     aNodes->ChangeMap().Add( anIndex );
286   aMesh->SetHiddenNodes( aNodes );
287   aMesh->SetSelectableNodes ( aNodes );
288
289   VDisplayAISObject(argv[1], aMesh);
290   aContext->Deactivate( aMesh );
291
292   Draw::Set( argv[1], new XSDRAWSTLVRML_DrawableMesh( aMesh ) );
293   Handle( V3d_View ) aView = ViewerTest::CurrentView();
294   if ( !aView.IsNull() )
295     aView->FitAll();
296
297   return 0;
298 }
299 //-----------------------------------------------------------------------------
300
301 static Standard_Integer create3d
302 (Draw_Interpretor& di, Standard_Integer argc, const char** argv )
303 {
304   if (argc<2)
305   {
306     di << "Wrong number of parameters\n";
307     di << "Use: " << argv[0] << " <mesh name>\n";
308     return 0;
309   }
310
311   Handle(AIS_InteractiveContext) aContext = ViewerTest::GetAISContext();
312   if (aContext.IsNull())
313   {
314     di << "No active view. Please call 'vinit' first\n";
315     return 0;
316   }
317
318   Handle( XSDRAWSTLVRML_DataSource3D ) aDS = new XSDRAWSTLVRML_DataSource3D();
319   di << "Data source is created successful\n";
320   Handle( MeshVS_Mesh ) aMesh = new MeshVS_Mesh();
321   di << "MeshVS_Mesh is created successful\n";
322
323   aMesh->SetDataSource( aDS );
324   aMesh->AddBuilder( new MeshVS_MeshPrsBuilder( aMesh.operator->() ), Standard_True );
325
326   aMesh->GetDrawer()->SetColor( MeshVS_DA_EdgeColor, Quantity_NOC_YELLOW );
327
328   // Hide all nodes by default
329   Handle(TColStd_HPackedMapOfInteger) aNodes = new TColStd_HPackedMapOfInteger();
330   Standard_Integer aLen = aDS->GetAllNodes().Extent();
331   for ( Standard_Integer anIndex = 1; anIndex <= aLen; anIndex++ )
332     aNodes->ChangeMap().Add( anIndex );
333   aMesh->SetHiddenNodes( aNodes );
334   aMesh->SetSelectableNodes ( aNodes );
335
336   VDisplayAISObject(argv[1], aMesh);
337   aContext->Deactivate( aMesh );
338
339   Draw::Set( argv[1], new XSDRAWSTLVRML_DrawableMesh( aMesh ) );
340   Handle( V3d_View ) aView = ViewerTest::CurrentView();
341   if ( !aView.IsNull() )
342     aView->FitAll();
343
344   return 0;
345 }
346
347 Handle( MeshVS_Mesh ) getMesh( const char* theName, Draw_Interpretor& di)
348 {
349   Handle( XSDRAWSTLVRML_DrawableMesh ) aDrawMesh =
350     Handle( XSDRAWSTLVRML_DrawableMesh )::DownCast( Draw::Get( theName ) );
351
352   if( aDrawMesh.IsNull() )
353   {
354     di << "There is no such object\n";
355     return NULL;
356   }
357   else
358   {
359     Handle( MeshVS_Mesh ) aMesh = aDrawMesh->GetMesh();
360     if( aMesh.IsNull() )
361     {
362       di << "There is invalid mesh\n";
363       return NULL;
364     }
365     else
366       return aMesh;
367   }
368 }
369
370 //-----------------------------------------------------------------------------
371 static Standard_Integer setcolor
372 (Draw_Interpretor& di, Standard_Integer argc, const char** argv, Standard_Integer theParam )
373 {
374   if (argc<5)
375     di << "Wrong number of parameters\n";
376   else
377   {
378     Handle( MeshVS_Mesh ) aMesh = getMesh( argv[1], di );
379     if( !aMesh.IsNull() )
380     {
381       Standard_Real aRed = Draw::Atof (argv[2]);
382       Standard_Real aGreen = Draw::Atof (argv[3]);
383       Standard_Real aBlue = Draw::Atof (argv[4]);
384       aMesh->GetDrawer()->SetColor( (MeshVS_DrawerAttribute)theParam,
385                                     Quantity_Color( aRed, aGreen, aBlue, Quantity_TOC_RGB ) );
386
387       Handle( AIS_InteractiveContext ) aContext = ViewerTest::GetAISContext();
388
389       if( aContext.IsNull() )
390         di << "The context is null\n";
391       else
392         aContext->Redisplay( aMesh );
393     }
394   }
395   return 0;
396 }
397 //-----------------------------------------------------------------------------
398 static Standard_Integer meshcolor
399 (Draw_Interpretor& theInterp, Standard_Integer argc, const char** argv )
400 {
401   return setcolor( theInterp, argc, argv, MeshVS_DA_InteriorColor );
402 }
403 //-----------------------------------------------------------------------------
404 static Standard_Integer linecolor
405 (Draw_Interpretor& theInterp, Standard_Integer argc, const char** argv )
406 {
407   return setcolor( theInterp, argc, argv, MeshVS_DA_EdgeColor );
408 }
409 //-----------------------------------------------------------------------------
410 static Standard_Integer meshmat
411 (Draw_Interpretor& di, Standard_Integer argc, const char** argv )
412 {
413   if (argc<3)
414     di << "Wrong number of parameters\n";
415   else
416   {
417     Handle( MeshVS_Mesh ) aMesh = getMesh( argv[1], di );
418     if( !aMesh.IsNull() )
419     {
420       Standard_Integer aMaterial = Draw::Atoi (argv[2]);
421
422       Graphic3d_MaterialAspect aMatAsp =
423         (Graphic3d_MaterialAspect)(Graphic3d_NameOfMaterial)aMaterial;
424
425       if (argc == 4)
426       {
427         Standard_Real aTransparency = Draw::Atof(argv[3]);
428         aMatAsp.SetTransparency(aTransparency);
429       }
430       aMesh->GetDrawer()->SetMaterial( MeshVS_DA_FrontMaterial, aMatAsp );
431       aMesh->GetDrawer()->SetMaterial( MeshVS_DA_BackMaterial, aMatAsp );
432
433       Handle( AIS_InteractiveContext ) aContext = ViewerTest::GetAISContext();
434
435       if( aContext.IsNull() )
436         di << "The context is null\n";
437       else
438         aContext->Redisplay( aMesh );
439     }
440   }
441   return 0;
442 }
443 //-----------------------------------------------------------------------------
444 static Standard_Integer shrink
445 (Draw_Interpretor& di, Standard_Integer argc, const char** argv )
446 {
447   if (argc<3)
448     di << "Wrong number of parameters\n";
449   else
450   {
451     Handle( MeshVS_Mesh ) aMesh = getMesh( argv[1], di );
452     if( !aMesh.IsNull() )
453     {
454       Standard_Real aShrinkCoeff = Draw::Atof (argv[2]);
455       aMesh->GetDrawer()->SetDouble( MeshVS_DA_ShrinkCoeff, aShrinkCoeff );
456
457       Handle( AIS_InteractiveContext ) aContext = ViewerTest::GetAISContext();
458
459       if( aContext.IsNull() )
460         di << "The context is null\n";
461       else
462         aContext->Redisplay( aMesh );
463     }
464   }
465   return 0;
466 }
467
468 //-----------------------------------------------------------------------------
469 static Standard_Integer closed (Draw_Interpretor& theDI, Standard_Integer theArgc, const char** theArgv)
470 {
471   if (theArgc < 3)
472   {
473     theDI << "Wrong number of parameters.\n";
474   }
475   else
476   {
477     Handle(MeshVS_Mesh) aMesh = getMesh (theArgv[1], theDI);
478     if (!aMesh.IsNull())
479     {
480       Standard_Boolean aFlag = Draw::Atoi (theArgv[2]) != 0;
481       aMesh->GetDrawer()->SetBoolean (MeshVS_DA_SupressBackFaces, aFlag);
482
483       Handle( AIS_InteractiveContext ) aContext = ViewerTest::GetAISContext();
484       if (aContext.IsNull())
485       {
486         theDI << "The context is null\n";
487       }
488       else
489       {
490         aContext->Redisplay (aMesh);
491       }
492     }
493   }
494   return 0;
495 }
496
497 //-----------------------------------------------------------------------------
498
499 static Standard_Integer mdisplay
500 (Draw_Interpretor& di, Standard_Integer argc, const char** argv )
501 {
502   if (argc<2)
503     di << "Wrong number of parameters\n";
504   else
505   {
506     Handle( MeshVS_Mesh ) aMesh = getMesh( argv[1], di );
507     if( !aMesh.IsNull() )
508     {
509       Handle( AIS_InteractiveContext ) aContext = ViewerTest::GetAISContext();
510
511       if( aContext.IsNull() )
512         di << "The context is null\n";
513       else
514       {
515         if( aContext->HasOpenedContext() )
516           aContext->CloseLocalContext();
517
518         aContext->Display( aMesh );
519       }
520     }
521   }
522   return 0;
523 }
524 //-----------------------------------------------------------------------------
525 static Standard_Integer merase
526 (Draw_Interpretor& di, Standard_Integer argc, const char** argv )
527 {
528   if (argc<2)
529     di << "Wrong number of parameters\n";
530   else
531   {
532     Handle( MeshVS_Mesh ) aMesh = getMesh( argv[1], di );
533     if( !aMesh.IsNull() )
534     {
535       Handle( AIS_InteractiveContext ) aContext = ViewerTest::GetAISContext();
536
537       if( aContext.IsNull() )
538         di << "The context is null\n";
539       else
540       {
541         if( aContext->HasOpenedContext() )
542           aContext->CloseLocalContext();
543
544         aContext->Erase( aMesh );
545       }
546     }
547     else
548       di << "Mesh is null\n";
549   }
550   return 0;
551 }
552 //-----------------------------------------------------------------------------
553 static Standard_Integer hidesel
554 (Draw_Interpretor& di, Standard_Integer argc, const char** argv )
555 {
556   if (argc<2)
557   {
558     di << "Wrong number of parameters\n";
559     di << "Use: " << argv[0] << " <mesh name>\n";
560     return 0;
561   }
562
563   Handle( AIS_InteractiveContext ) aContext = ViewerTest::GetAISContext();
564   Handle( MeshVS_Mesh ) aMesh = getMesh( argv[1], di );
565   if( aMesh.IsNull() )
566   {
567     di << "The mesh is invalid\n";
568     return 0;
569   }
570
571   if( aContext.IsNull() )
572     di << "The context is null\n";
573   else
574   {
575     Handle(TColStd_HPackedMapOfInteger) aHiddenNodes = aMesh->GetHiddenNodes();
576     if (aHiddenNodes.IsNull())
577     {
578       aHiddenNodes = new TColStd_HPackedMapOfInteger();
579     }
580     Handle(TColStd_HPackedMapOfInteger) aHiddenElements = aMesh->GetHiddenElems();
581     if (aHiddenElements.IsNull())
582     {
583       aHiddenElements = new TColStd_HPackedMapOfInteger();
584     }
585     for( aContext->InitSelected(); aContext->MoreSelected(); aContext->NextSelected() )
586     {
587       Handle( MeshVS_MeshEntityOwner ) anOwner =
588         Handle( MeshVS_MeshEntityOwner )::DownCast( aContext->SelectedOwner() );
589       if( !anOwner.IsNull() )
590       {
591         if( anOwner->Type()==MeshVS_ET_Node )
592         {
593           aHiddenNodes->ChangeMap().Add( anOwner->ID() );
594         }
595         else
596         {
597           aHiddenElements->ChangeMap().Add( anOwner->ID() );
598         }
599       }
600     }
601     aContext->ClearSelected();
602     aMesh->SetHiddenNodes( aHiddenNodes );
603     aMesh->SetHiddenElems( aHiddenElements );
604     aContext->Redisplay( aMesh );
605   }
606
607   return 0;
608 }
609 //-----------------------------------------------------------------------------
610 static Standard_Integer showonly
611 (Draw_Interpretor& di, Standard_Integer argc, const char** argv )
612 {
613   if (argc<2)
614   {
615     di << "Wrong number of parameters\n";
616     di << "Use: " << argv[0] << " <mesh name>\n";
617     return 0;
618   }
619
620
621   Handle( AIS_InteractiveContext ) aContext = ViewerTest::GetAISContext();
622   Handle( MeshVS_Mesh ) aMesh = getMesh( argv[1], di );
623   if( aMesh.IsNull() )
624   {
625     di << "The mesh is invalid\n";
626     return 0;
627   }
628
629   if( aContext.IsNull() )
630     di << "The context is null\n";
631   else
632   {
633     Handle(TColStd_HPackedMapOfInteger) aHiddenNodes =
634       new TColStd_HPackedMapOfInteger(aMesh->GetDataSource()->GetAllNodes());
635     Handle(TColStd_HPackedMapOfInteger) aHiddenElements =
636       new TColStd_HPackedMapOfInteger(aMesh->GetDataSource()->GetAllElements());
637     for( aContext->InitSelected(); aContext->MoreSelected(); aContext->NextSelected() )
638     {
639       Handle( MeshVS_MeshEntityOwner ) anOwner =
640         Handle( MeshVS_MeshEntityOwner )::DownCast( aContext->SelectedOwner() );
641       if( !anOwner.IsNull() )
642       {
643         if( anOwner->Type() == MeshVS_ET_Node )
644         {
645           aHiddenNodes->ChangeMap().Remove( anOwner->ID() );
646         }
647         else
648         {
649           aHiddenElements->ChangeMap().Remove( anOwner->ID() );
650         }
651       }
652     }
653     aMesh->SetHiddenNodes( aHiddenNodes );
654     aMesh->SetHiddenElems( aHiddenElements );
655     aContext->Redisplay( aMesh );
656   }
657
658   return 0;
659 }
660 //-----------------------------------------------------------------------------
661 static Standard_Integer showall
662 (Draw_Interpretor& di, Standard_Integer argc, const char** argv )
663 {
664   if (argc<2)
665   {
666     di << "Wrong number of parameters\n";
667     di << "Use: " << argv[0] << " <mesh name>\n";
668     return 0;
669   }
670
671   Handle( AIS_InteractiveContext ) aContext = ViewerTest::GetAISContext();
672   Handle( MeshVS_Mesh ) aMesh = getMesh( argv[1], di );
673   if( aMesh.IsNull() )
674   {
675     di << "The mesh is invalid\n";
676     return 0;
677   }
678
679   if( aContext.IsNull() )
680     di << "The context is null\n";
681   else
682   {
683     aMesh->SetHiddenNodes( new TColStd_HPackedMapOfInteger() );
684     aMesh->SetHiddenElems( new TColStd_HPackedMapOfInteger() );
685     aContext->Redisplay( aMesh );
686   }
687
688   return 0;
689 }
690
691 //-----------------------------------------------------------------------------
692 static Standard_Integer meshcolors( Draw_Interpretor& di,
693                                     Standard_Integer argc,
694                                     const char** argv )
695 {
696   try
697   {
698     OCC_CATCH_SIGNALS
699       if ( argc < 4 )
700       {
701         di << "Wrong number of parameters\n";
702         di << "Use : meshcolors <mesh name> <mode> <isreflect>\n";
703         di << "mode : {elem1|elem2|nodal|nodaltex|none}\n";
704         di << "       elem1 - different color for each element\n";
705         di << "       elem2 - one color for one side\n";
706         di << "       nodal - different color for each node\n";
707         di << "       nodaltex - different color for each node with texture interpolation\n";
708         di << "       none  - clear\n";
709         di << "isreflect : {0|1} \n";
710
711         return 0;
712       }
713
714       Handle( MeshVS_Mesh ) aMesh = getMesh( argv[ 1 ], di );
715
716       if ( aMesh.IsNull() )
717       {
718         di << "Mesh not found\n";
719         return 0;
720       }
721       Handle(AIS_InteractiveContext) anIC = ViewerTest::GetAISContext();
722       if ( anIC.IsNull() )
723       {
724         di << "The context is null\n";
725         return 0;
726       }
727       if( !aMesh.IsNull() )
728       {
729         TCollection_AsciiString aMode = TCollection_AsciiString (argv[2]);
730         Quantity_Color aColor1( (Quantity_NameOfColor)( Quantity_NOC_BLUE1 ) );
731         Quantity_Color aColor2( (Quantity_NameOfColor)( Quantity_NOC_RED1 ) );
732         if( aMode.IsEqual("elem1") || aMode.IsEqual("elem2") || aMode.IsEqual("nodal") || aMode.IsEqual("nodaltex") || aMode.IsEqual("none") )
733         {
734           Handle(MeshVS_PrsBuilder) aTempBuilder;
735           Standard_Integer aReflection = Draw::Atoi(argv[3]);
736
737           for (Standard_Integer aCount = 0 ; aCount < aMesh->GetBuildersCount(); aCount++ ){
738             aTempBuilder = aMesh->FindBuilder("MeshVS_ElementalColorPrsBuilder");
739             if( !aTempBuilder.IsNull())
740               aMesh->RemoveBuilderById(aTempBuilder->GetId());
741
742             aTempBuilder = aMesh->FindBuilder("MeshVS_NodalColorPrsBuilder");
743             if( !aTempBuilder.IsNull())
744               aMesh->RemoveBuilderById(aTempBuilder->GetId());
745           }
746
747           if( aMode.IsEqual("elem1") || aMode.IsEqual("elem2") )
748           {
749             Handle(MeshVS_ElementalColorPrsBuilder) aBuilder = new MeshVS_ElementalColorPrsBuilder(
750                 aMesh, MeshVS_DMF_ElementalColorDataPrs | MeshVS_DMF_OCCMask );
751               // Color
752             const TColStd_PackedMapOfInteger& anAllElements = aMesh->GetDataSource()->GetAllElements();
753             TColStd_MapIteratorOfPackedMapOfInteger anIter( anAllElements );
754
755             if( aMode.IsEqual("elem1") )
756               for ( ; anIter.More(); anIter.Next() )
757               {
758                 Quantity_Color aColor( (Quantity_NameOfColor)( anIter.Key() % Quantity_NOC_WHITE ) );
759                 aBuilder->SetColor1( anIter.Key(), aColor );
760               }
761             else
762               for ( ; anIter.More(); anIter.Next() )
763                 aBuilder->SetColor2( anIter.Key(), aColor1, aColor2 );
764
765             aMesh->AddBuilder( aBuilder, Standard_True );
766           }
767
768
769           if( aMode.IsEqual("nodal") )
770           {
771             Handle(MeshVS_NodalColorPrsBuilder) aBuilder = new MeshVS_NodalColorPrsBuilder(
772                 aMesh, MeshVS_DMF_NodalColorDataPrs | MeshVS_DMF_OCCMask );
773             aMesh->AddBuilder( aBuilder, Standard_True );
774
775             // Color
776             const TColStd_PackedMapOfInteger& anAllNodes =
777               aMesh->GetDataSource()->GetAllNodes();
778             TColStd_MapIteratorOfPackedMapOfInteger anIter( anAllNodes );
779             for ( ; anIter.More(); anIter.Next() )
780             {
781               Quantity_Color aColor( (Quantity_NameOfColor)(
782                 anIter.Key() % Quantity_NOC_WHITE ) );
783               aBuilder->SetColor( anIter.Key(), aColor );
784             }
785             aMesh->AddBuilder( aBuilder, Standard_True );
786           }
787
788           if(aMode.IsEqual("nodaltex"))
789           {
790             // assign nodal builder to the mesh
791             Handle(MeshVS_NodalColorPrsBuilder) aBuilder = new MeshVS_NodalColorPrsBuilder(
792                    aMesh, MeshVS_DMF_NodalColorDataPrs | MeshVS_DMF_OCCMask);
793             aMesh->AddBuilder(aBuilder, Standard_True);
794             aBuilder->UseTexture(Standard_True);
795
796             // prepare color map for texture
797             Aspect_SequenceOfColor aColorMap;
798             aColorMap.Append((Quantity_NameOfColor) Quantity_NOC_RED);
799             aColorMap.Append((Quantity_NameOfColor) Quantity_NOC_YELLOW);
800             aColorMap.Append((Quantity_NameOfColor) Quantity_NOC_BLUE1);
801
802             // prepare scale map for mesh - it will be assigned to mesh as texture coordinates
803             // make mesh color interpolated from minimum X coord to maximum X coord
804             Handle(MeshVS_DataSource) aDataSource = aMesh->GetDataSource();
805             Standard_Real aMinX, aMinY, aMinZ, aMaxX, aMaxY, aMaxZ;
806
807             // get bounding box for calculations
808             aDataSource->GetBoundingBox().Get(aMinX, aMinY, aMinZ, aMaxX, aMaxY, aMaxZ);
809             Standard_Real aDelta = aMaxX - aMinX;
810
811             // assign color scale map values (0..1) to nodes
812             TColStd_DataMapOfIntegerReal aScaleMap;
813             TColStd_Array1OfReal aCoords(1, 3);
814             Standard_Integer     aNbNodes;
815             MeshVS_EntityType    aType;
816
817             // iterate nodes
818             const TColStd_PackedMapOfInteger& anAllNodes =
819                   aMesh->GetDataSource()->GetAllNodes();
820             TColStd_MapIteratorOfPackedMapOfInteger anIter(anAllNodes);
821             for (; anIter.More(); anIter.Next())
822             {
823               //get node coordinates to aCoord variable
824               aDataSource->GetGeom(anIter.Key(), Standard_False, aCoords, aNbNodes, aType);
825
826               Standard_Real aScaleValue;
827               try {
828                 OCC_CATCH_SIGNALS
829                 aScaleValue = (aCoords.Value(1) - (Standard_Real) aMinX) / aDelta;
830               } catch(Standard_Failure) {
831                 aScaleValue = 0;
832               }
833
834               aScaleMap.Bind(anIter.Key(), aScaleValue);
835             }
836
837             //set color map for builder and a color for invalid scale value
838             aBuilder->SetColorMap(aColorMap);
839             aBuilder->SetInvalidColor(Quantity_NOC_BLACK);
840             aBuilder->SetTextureCoords(aScaleMap);
841             aMesh->AddBuilder(aBuilder, Standard_True);
842           }
843
844           aMesh->GetDrawer()->SetBoolean (MeshVS_DA_ColorReflection, aReflection != 0);
845
846           anIC->Redisplay( aMesh );
847         }
848         else
849         {
850           di << "Wrong mode name\n";
851           return 0;
852         }
853       }
854   }
855   catch ( Standard_Failure )
856   {
857     di << "Error\n";
858   }
859
860   return 0;
861 }
862 //-----------------------------------------------------------------------------
863 static Standard_Integer meshvectors( Draw_Interpretor& di,
864                                      Standard_Integer argc,
865                                      const char** argv )
866 {
867   if ( argc < 3 )
868   {
869     di << "Wrong number of parameters\n";
870     di << "Use : meshvectors <mesh name> < -mode {elem|nodal|none} > [-maxlen len] [-color name] [-arrowpart ratio] [-issimple {1|0}]\n";
871     di << "Supported mode values:\n";
872     di << "       elem  - vector per element\n";
873     di << "       nodal - vector per node\n";
874     di << "       none  - clear\n";
875
876     return 0;
877   }
878
879   Handle( MeshVS_Mesh ) aMesh = getMesh( argv[ 1 ], di );
880
881   if ( aMesh.IsNull() )
882   {
883     di << "Mesh not found\n";
884     return 0;
885   }
886   Handle(AIS_InteractiveContext) anIC = ViewerTest::GetAISContext();
887   if ( anIC.IsNull() )
888   {
889     di << "The context is null\n";
890     return 0;
891   }
892
893   TCollection_AsciiString aParam;
894   TCollection_AsciiString aMode("none");
895   Standard_Real           aMaxlen(1.0);
896   Quantity_Color          aColor(Quantity_NOC_ORANGE);
897   Standard_Real           anArrowPart(0.1);
898   Standard_Boolean        isSimplePrs(Standard_False);
899
900   for (Standard_Integer anIdx = 2; anIdx < argc; anIdx++)
901   {
902     if (!aParam.IsEmpty())
903     {
904       if (aParam == "-mode")
905       {
906         aMode       = argv[anIdx];
907       }
908       else if (aParam == "-maxlen")
909       {
910         aMaxlen     = Draw::Atof(argv[anIdx]);
911       }
912       else if (aParam == "-color")
913       {
914         aColor      = ViewerTest::GetColorFromName(argv[anIdx]);
915       }
916       else if (aParam == "-arrowpart")
917       {
918         anArrowPart = Draw::Atof(argv[anIdx]);
919       }
920       else if (aParam == "-issimple")
921       {
922         isSimplePrs = Draw::Atoi(argv[anIdx]) != 0;
923       }
924       aParam.Clear();
925     }
926     else if (argv[anIdx][0] == '-')
927     {
928       aParam = argv[anIdx];
929     }
930   }
931
932   if( !aMode.IsEqual("elem") && !aMode.IsEqual("nodal") && !aMode.IsEqual("none") )
933   {
934     di << "Wrong mode name\n";
935     return 0;
936   }
937
938   Handle(MeshVS_PrsBuilder) aTempBuilder;
939
940   aTempBuilder = aMesh->FindBuilder("MeshVS_VectorPrsBuilder");
941   if( !aTempBuilder.IsNull())
942     aMesh->RemoveBuilderById(aTempBuilder->GetId());
943
944   if( !aMode.IsEqual("none") )
945   {
946     Handle(MeshVS_VectorPrsBuilder) aBuilder = new MeshVS_VectorPrsBuilder( aMesh.operator->(), 
947                                                                             aMaxlen,
948                                                                             aColor,
949                                                                             MeshVS_DMF_VectorDataPrs,
950                                                                             0,
951                                                                             -1,
952                                                                             MeshVS_BP_Vector,
953                                                                             isSimplePrs);
954
955     Standard_Boolean anIsElement = aMode.IsEqual("elem");
956     const TColStd_PackedMapOfInteger& anAllIDs = anIsElement ? aMesh->GetDataSource()->GetAllElements() :
957                                                                aMesh->GetDataSource()->GetAllNodes();
958
959     Standard_Integer aNbNodes;
960     MeshVS_EntityType aEntType;
961
962     TColStd_Array1OfReal aCoords(1, 3);
963     aCoords.Init (0.);
964     TColStd_MapIteratorOfPackedMapOfInteger anIter( anAllIDs );
965     for ( ; anIter.More(); anIter.Next() )
966     {
967       Standard_Boolean IsValidData = Standard_False; 
968       if (anIsElement) {
969         aMesh->GetDataSource()->GetGeomType(anIter.Key(), anIsElement, aEntType);
970         if (aEntType == MeshVS_ET_Face)
971           IsValidData = aMesh->GetDataSource()->GetNormal(anIter.Key(), 3, aCoords.ChangeValue(1), aCoords.ChangeValue(2), aCoords.ChangeValue(3));
972       } else
973         IsValidData = aMesh->GetDataSource()->GetGeom(anIter.Key(), Standard_False, aCoords, aNbNodes, aEntType);
974
975       gp_Vec aNorm;
976       if(IsValidData)
977       { 
978         aNorm = gp_Vec(aCoords.Value(1), aCoords.Value(2), aCoords.Value(3));
979         if(aNorm.Magnitude() < gp::Resolution())
980         {
981           aNorm = gp_Vec(0,0,1); //method GetGeom(...) returns coordinates of nodes
982         }
983       }
984       else
985       {
986         aNorm = gp_Vec(0,0,1);
987       }
988       aBuilder->SetVector(anIsElement, anIter.Key(), aNorm.Normalized());
989     }
990
991     aMesh->AddBuilder( aBuilder, Standard_False );
992     aMesh->GetDrawer()->SetDouble ( MeshVS_DA_VectorArrowPart, anArrowPart );
993   }
994
995   anIC->Redisplay( aMesh );
996
997   return 0;
998 }
999 //-----------------------------------------------------------------------------
1000
1001 static Standard_Integer meshtext( Draw_Interpretor& di,
1002                                   Standard_Integer argc,
1003                                   const char** argv )
1004 {
1005   if ( argc < 2 )
1006   {
1007     di << "Wrong number of parameters\n";
1008     di << "Use : meshtext <mesh name>\n";
1009     return 0;
1010   }
1011
1012   Handle( MeshVS_Mesh ) aMesh = getMesh( argv[ 1 ], di );
1013
1014   if ( aMesh.IsNull() )
1015   {
1016     di << "Mesh not found\n";
1017     return 0;
1018   }
1019
1020   Handle(AIS_InteractiveContext) anIC = ViewerTest::GetAISContext();
1021   if ( anIC.IsNull() )
1022   {
1023     di << "The context is null\n";
1024     return 0;
1025   }
1026
1027   // Prepare triangle labels
1028   MeshVS_DataMapOfIntegerAsciiString aLabels;
1029   Standard_Integer aLen = aMesh->GetDataSource()->GetAllElements().Extent();
1030   for ( Standard_Integer anIndex = 1; anIndex <= aLen; anIndex++ ){
1031     aLabels.Bind( anIndex, TCollection_AsciiString( anIndex ) );
1032   }
1033
1034   Handle(MeshVS_TextPrsBuilder) aTextBuilder = new MeshVS_TextPrsBuilder( aMesh.operator->(), 20., Quantity_NOC_YELLOW );
1035   aTextBuilder->SetTexts( Standard_True, aLabels );
1036   aMesh->AddBuilder( aTextBuilder );
1037
1038   return 0;
1039 }
1040
1041 static Standard_Integer meshdeform( Draw_Interpretor& di,
1042                                     Standard_Integer argc,
1043                                     const char** argv )
1044 {
1045   if ( argc < 3 )
1046   {
1047     di << "Wrong number of parameters\n";
1048     di << "Use : meshdeform <mesh name> < -mode {on|off} > [-scale scalefactor]\n";
1049     return 0;
1050   }
1051
1052   Handle( MeshVS_Mesh ) aMesh = getMesh( argv[ 1 ], di );
1053
1054   if ( aMesh.IsNull() )
1055   {
1056     di << "Mesh not found\n";
1057     return 0;
1058   }
1059   Handle(AIS_InteractiveContext) anIC = ViewerTest::GetAISContext();
1060   if ( anIC.IsNull() )
1061   {
1062     di << "The context is null\n";
1063     return 0;
1064   }
1065
1066   TCollection_AsciiString aParam;
1067   TCollection_AsciiString aMode("off");
1068   Standard_Real           aScale(1.0);
1069
1070   for (Standard_Integer anIdx = 2; anIdx < argc; anIdx++)
1071   {
1072     if (!aParam.IsEmpty())
1073     {
1074       if (aParam == "-mode")
1075       {
1076         aMode = argv[anIdx];
1077       }
1078       else if (aParam == "-scale")
1079       {
1080         aScale = Draw::Atof(argv[anIdx]);
1081       }
1082       aParam.Clear();
1083     }
1084     else if (argv[anIdx][0] == '-')
1085     {
1086       aParam = argv[anIdx];
1087     }
1088   }
1089
1090   if(!aMode.IsEqual("on") && !aMode.IsEqual("off"))
1091   {
1092     di << "Wrong mode name\n";
1093     return 0;
1094   }
1095
1096   Handle ( MeshVS_DeformedDataSource ) aDefDS =
1097     new MeshVS_DeformedDataSource( aMesh->GetDataSource() , aScale );
1098
1099   const TColStd_PackedMapOfInteger& anAllIDs = aMesh->GetDataSource()->GetAllNodes();
1100
1101   Standard_Integer aNbNodes;
1102   MeshVS_EntityType aEntType;
1103
1104   TColStd_MapIteratorOfPackedMapOfInteger anIter( anAllIDs );
1105   for ( ; anIter.More(); anIter.Next() )
1106   {
1107     TColStd_Array1OfReal aCoords(1, 3);
1108     aMesh->GetDataSource()->GetGeom(anIter.Key(), Standard_False, aCoords, aNbNodes, aEntType);
1109
1110     gp_Vec aNorm = gp_Vec(aCoords.Value(1), aCoords.Value(2), aCoords.Value(3));
1111     if( !aNorm.Magnitude() )
1112       aNorm = gp_Vec(0,0,1);
1113     aDefDS->SetVector(anIter.Key(), aNorm.Normalized());
1114   }
1115
1116   aMesh->SetDataSource(aDefDS);
1117
1118   anIC->Redisplay( aMesh );
1119
1120   Handle( V3d_View ) aView = ViewerTest::CurrentView();
1121   if ( !aView.IsNull() )
1122     aView->FitAll();
1123
1124   return 0;
1125 }
1126
1127 static Standard_Integer mesh_edge_width( Draw_Interpretor& di,
1128                                         Standard_Integer argc,
1129                                         const char** argv )
1130 {
1131   try
1132   {
1133     OCC_CATCH_SIGNALS
1134       if ( argc < 3 )
1135       {
1136         di << "Wrong number of parameters\n";
1137         di << "Use : mesh_edge_width <mesh name> <width>\n";
1138         return 0;
1139       }
1140
1141       Handle(MeshVS_Mesh) aMesh = getMesh( argv[ 1 ], di );
1142       if ( aMesh.IsNull() )
1143       {
1144         di << "Mesh not found\n";
1145         return 0;
1146       }
1147
1148       const char* aWidthStr = argv[ 2 ];
1149       if ( aWidthStr == 0 || Draw::Atof( aWidthStr ) <= 0 )
1150       {
1151         di << "Width must be real value more than zero\n";
1152         return 0;
1153       }
1154
1155       double aWidth = Draw::Atof( aWidthStr );
1156
1157       Handle(AIS_InteractiveContext) anIC = ViewerTest::GetAISContext();
1158       if ( anIC.IsNull() )
1159       {
1160         di << "The context is null\n";
1161         return 0;
1162       }
1163
1164       Handle(MeshVS_Drawer) aDrawer = aMesh->GetDrawer();
1165       if ( aDrawer.IsNull() )
1166       {
1167         di << "The drawer is null\n";
1168         return 0;
1169       }
1170
1171       aDrawer->SetDouble( MeshVS_DA_EdgeWidth, aWidth );
1172       anIC->Redisplay( aMesh );
1173   }
1174   catch ( Standard_Failure )
1175   {
1176     di << "Error\n";
1177   }
1178
1179   return 0;
1180 }
1181
1182 //-----------------------------------------------------------------------------
1183
1184 static Standard_Integer meshinfo(Draw_Interpretor& di,
1185                                  Standard_Integer argc,
1186                                  const char** argv)
1187 {
1188   if ( argc != 2 )
1189   {
1190     di << "Wrong number of parameters. Use : meshinfo mesh\n";
1191     return 0;
1192   }
1193
1194   Handle(MeshVS_Mesh) aMesh = getMesh(argv[ 1 ], di);
1195   if ( aMesh.IsNull() )
1196   {
1197     di << "Mesh not found\n";
1198     return 0;
1199   }
1200
1201   Handle(XSDRAWSTLVRML_DataSource) stlMeshSource = Handle(XSDRAWSTLVRML_DataSource)::DownCast(aMesh->GetDataSource());
1202   if (!stlMeshSource.IsNull())
1203   {
1204     const TColStd_PackedMapOfInteger& nodes = stlMeshSource->GetAllNodes();
1205     const TColStd_PackedMapOfInteger& tris  = stlMeshSource->GetAllElements();
1206
1207     di << "Nb nodes = " << nodes.Extent() << "\n";
1208     di << "Nb triangles = " << tris.Extent() << "\n";
1209   }
1210
1211   return 0;
1212 }
1213
1214 //-----------------------------------------------------------------------------
1215
1216 void  XSDRAWSTLVRML::InitCommands (Draw_Interpretor& theCommands)
1217 {
1218   const char* g = "XSTEP-STL/VRML";  // Step transfer file commands
1219   //XSDRAW::LoadDraw(theCommands);
1220
1221   theCommands.Add ("writevrml", "shape file [version VRML#1.0/VRML#2.0 (1/2): 2 by default] [representation shaded/wireframe/both (0/1/2): 1 by default]",__FILE__,writevrml,g);
1222   theCommands.Add ("writestl",  "shape file [ascii/binary (0/1) : 1 by default] [InParallel (0/1) : 0 by default]",__FILE__,writestl,g);
1223   theCommands.Add ("readstl",   "shape file",__FILE__,readstl,g);
1224   theCommands.Add ("loadvrml" , "shape file",__FILE__,loadvrml,g);
1225
1226   theCommands.Add ("meshfromstl",     "creates MeshVS_Mesh from STL file",            __FILE__, createmesh,      g );
1227   theCommands.Add ("mesh3delem",      "creates 3d element mesh to test",              __FILE__, create3d,        g );
1228   theCommands.Add ("meshshadcolor",   "change MeshVS_Mesh shading color",             __FILE__, meshcolor,       g );
1229   theCommands.Add ("meshlinkcolor",   "change MeshVS_Mesh line color",                __FILE__, linecolor,       g );
1230   theCommands.Add ("meshmat",         "change MeshVS_Mesh material and transparency", __FILE__, meshmat,         g );
1231   theCommands.Add ("meshshrcoef",     "change MeshVS_Mesh shrink coeff",              __FILE__, shrink,          g );
1232   theCommands.Add ("meshclosed",      "meshclosed meshname (0/1) \nChange MeshVS_Mesh drawing mode. 0 - not closed object, 1 - closed object", __FILE__, closed, g);
1233   theCommands.Add ("meshshow",        "display MeshVS_Mesh object",                   __FILE__, mdisplay,        g );
1234   theCommands.Add ("meshhide",        "erase MeshVS_Mesh object",                     __FILE__, merase,          g );
1235   theCommands.Add ("meshhidesel",     "hide selected entities",                       __FILE__, hidesel,         g );
1236   theCommands.Add ("meshshowsel",     "show only selected entities",                  __FILE__, showonly,        g );
1237   theCommands.Add ("meshshowall",     "show all entities",                            __FILE__, showall,         g );
1238   theCommands.Add ("meshcolors",      "display color presentation",                   __FILE__, meshcolors,      g );
1239   theCommands.Add ("meshvectors",     "display sample vectors",                       __FILE__, meshvectors,     g );
1240   theCommands.Add ("meshtext",        "display text labels",                          __FILE__, meshtext,        g );
1241   theCommands.Add ("meshdeform",      "display deformed mesh",                        __FILE__, meshdeform,      g );
1242   theCommands.Add ("mesh_edge_width", "set width of edges",                           __FILE__, mesh_edge_width, g );
1243   theCommands.Add ("meshinfo",        "displays the number of nodes and triangles",   __FILE__, meshinfo,        g );
1244 }
1245
1246 //==============================================================================
1247 // XSDRAWSTLVRML::Factory
1248 //==============================================================================
1249 void XSDRAWSTLVRML::Factory(Draw_Interpretor& theDI)
1250 {
1251   XSDRAWIGES::InitSelect();
1252   XSDRAWIGES::InitToBRep(theDI);
1253   XSDRAWIGES::InitFromBRep(theDI);
1254   XSDRAWSTEP::InitCommands(theDI);
1255   XSDRAWSTLVRML::InitCommands(theDI);
1256   XSDRAW::LoadDraw(theDI);
1257 #ifdef OCCT_DEBUG
1258   theDI << "Draw Plugin : All TKXSDRAW commands are loaded\n";
1259 #endif
1260 }
1261
1262 // Declare entry point PLUGINFACTORY
1263 DPLUGIN(XSDRAWSTLVRML)
1264