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