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