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