OCC22572 Support of progress indicator in RWStl and optimization of reading Ascii.
[occt.git] / src / XSDRAWSTLVRML / XSDRAWSTLVRML.cxx
CommitLineData
7fd59977 1// File: XSDRAWSTLVRML.cxx
2// Created: Tue May 30 17:29:50 2000
3// Author: Sergey MOZOKHIN
4// <smh@russox.nnov.matra-dtv.fr>
5
6
7#include <XSDRAWSTLVRML.ixx>
8#include <Draw_Interpretor.hxx>
9#include <TopoDS_Shape.hxx>
10#include <VrmlAPI.hxx>
11#include <OSD_Path.hxx>
12#include <StlAPI.hxx>
13#include <XSDRAW.hxx>
14#include <DBRep.hxx>
15#include <VrmlAPI_Writer.hxx>
16#include <Quantity_Color.hxx>
17#include <Quantity_HArray1OfColor.hxx>
18#include <StlAPI_Writer.hxx>
19#include <Draw_PluginMacro.hxx>
20#include <SWDRAW.hxx>
21#include <XSDRAW.hxx>
22#include <XSDRAWSTEP.hxx>
23#include <XSDRAWIGES.hxx>
24#include <AIS_InteractiveContext.hxx>
25#include <ViewerTest.hxx>
26#include <Draw.hxx>
9c6afe19 27#include <Draw_ProgressIndicator.hxx>
7fd59977 28#include <RWStl.hxx>
29#include <Quantity_Color.hxx>
30#include <V3d_View.hxx>
31#include <TCollection_AsciiString.hxx>
32
33#include <SelectMgr_SelectionManager.hxx>
34#include <StdSelect_ViewerSelector3d.hxx>
35
36#include <Aspect_TypeOfMarker.hxx>
37#include <Graphic3d_MaterialAspect.hxx>
38
39#include <StlMesh_Mesh.hxx>
40#include <StlMesh_SequenceOfMeshTriangle.hxx>
41
42#include <MeshVS_Mesh.hxx>
43#include <MeshVS_MeshPrsBuilder.hxx>
44#include <MeshVS_TextPrsBuilder.hxx>
45#include <MeshVS_Drawer.hxx>
46#include <MeshVS_DrawerAttribute.hxx>
47#include <MeshVS_MeshEntityOwner.hxx>
48#include <MeshVS_DataMapOfIntegerAsciiString.hxx>
49
50#include <XSDRAWSTLVRML_DataSource.hxx>
51#include <XSDRAWSTLVRML_DrawableMesh.hxx>
52#include <MeshVS_NodalColorPrsBuilder.hxx>
53#include <MeshVS_ElementalColorPrsBuilder.hxx>
54#include <Quantity_NameOfColor.hxx>
55#include <TColgp_SequenceOfXYZ.hxx>
56#include <TColStd_HPackedMapOfInteger.hxx>
57#include <TColStd_MapIteratorOfPackedMapOfInteger.hxx>
58#include <Standard_ErrorHandler.hxx>
59#include <VrmlData_Scene.hxx>
60#include <VrmlData_ShapeConvert.hxx>
61#include <VrmlData_DataMapOfShapeAppearance.hxx>
3ba3388b
A
62#include <TColStd_Array1OfReal.hxx>
63#include <Bnd_Box.hxx>
7fd59977 64
65// avoid warnings on 'extern "C"' functions returning C++ classes
66#ifdef WNT
67#pragma warning(4:4190)
68#endif
69
70#ifndef _STDIO_H
71#include <stdio.h>
72#endif
73
74static Standard_Integer writestl
75(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
76{
77 if (argc<3) di << "wrong number of parameters" << "\n";
78 else {
79 TopoDS_Shape shape = DBRep::Get(argv[1]);
80 // StlAPI_Writer writer;
81 // writer.ASCIIMode() = Standard_False;
82 // writer.Write (shape, "binary.stl");
83 StlAPI::Write(shape, argv[2],Standard_False); //now write in binary mode
84 }
85 return 0;
86}
87
88static Standard_Integer readstl
89(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
90{
91 if (argc<3) di << "wrong number of parameters" << "\n";
92 else {
93 TopoDS_Shape shape ;
94 StlAPI::Read(shape,argv[2]);
95 DBRep::Set(argv[1],shape);
96 }
97 return 0;
98}
99
100static Standard_Integer writevrml
101(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
102{
103 if (argc<3) di << "wrong number of parameters" << "\n";
104 else {
105 TopoDS_Shape shape = DBRep::Get(argv[1]);
106 // VrmlAPI_Writer writer;
107 // writer.SetTransparencyToMaterial(writer.GetFrontMaterial(),0.0);
108 // Quantity_Color color;
109 // color.SetValues(Quantity_NOC_GOLD);
110 // Handle(Quantity_HArray1OfColor) Col = new Quantity_HArray1OfColor(1,1);
111 // Col->SetValue(1,color);
112 // writer.SetDiffuseColorToMaterial(writer.GetFrontMaterial(),Col);
113 // writer.SetRepresentation(VrmlAPI_ShadedRepresentation);
114 // writer.SetDeflection(0.01);
115 // writer.Write(shape, argv[2]);
116 VrmlAPI::Write(shape, argv[2]);
117 }
118 return 0;
119}
120
121//=======================================================================
122//function : loadvrml
9c6afe19 123//purpose :
7fd59977 124//=======================================================================
125
126static Standard_Integer loadvrml
127(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
128{
129 if (argc<3) di << "wrong number of parameters" << "\n";
130 else {
131 TopoDS_Shape shape ;
132 VrmlData_DataMapOfShapeAppearance ShapeAppMap;
133
134 //-----------------------------------------------------------
135 filebuf fic;
136 istream aStream (&fic);
137
138 if (fic.open(argv[2], ios::in)) {
139
140 VrmlData_Scene aScene;
141
142 aScene.SetVrmlDir (".");
143 aScene << aStream;
144 const char * aStr = 0L;
145 switch (aScene.Status()) {
146
147 case VrmlData_StatusOK:
148 {
149 shape = aScene.GetShape(ShapeAppMap);
150 break;
151 }
152 case VrmlData_EmptyData: aStr = "EmptyData"; break;
153 case VrmlData_UnrecoverableError: aStr = "UnrecoverableError"; break;
154 case VrmlData_GeneralError: aStr = "GeneralError"; break;
155 case VrmlData_EndOfFile: aStr = "EndOfFile"; break;
156 case VrmlData_NotVrmlFile: aStr = "NotVrmlFile"; break;
157 case VrmlData_CannotOpenFile: aStr = "CannotOpenFile"; break;
158 case VrmlData_VrmlFormatError: aStr = "VrmlFormatError"; break;
159 case VrmlData_NumericInputError: aStr = "NumericInputError"; break;
160 case VrmlData_IrrelevantNumber: aStr = "IrrelevantNumber"; break;
161 case VrmlData_BooleanInputError: aStr = "BooleanInputError"; break;
162 case VrmlData_StringInputError: aStr = "StringInputError"; break;
163 case VrmlData_NodeNameUnknown: aStr = "NodeNameUnknown"; break;
164 case VrmlData_NonPositiveSize: aStr = "NonPositiveSize"; break;
165 case VrmlData_ReadUnknownNode: aStr = "ReadUnknownNode"; break;
166 case VrmlData_NonSupportedFeature:aStr = "NonSupportedFeature"; break;
167 }
168 if (aStr) {
169 di << " ++ VRML Error: " << aStr << " in line "
170 << aScene.GetLineError() << "\n";
171 }
172 else {
173 DBRep::Set(argv[1],shape);
174 }
175 }
176 else {
177 di << "cannot open file" << "\n";
178 }
179
180
181 //-----------------------------------------------------------
182 }
183 return 0;
184}
185
186//=======================================================================
187//function : storevrml
9c6afe19 188//purpose :
7fd59977 189//=======================================================================
190
191static Standard_Integer storevrml
192(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
193{
194 if (argc < 4) {
195 di << "wrong number of parameters" << "\n";
196 di << "use: storevrml shape file defl type_of_conversion (0, 1, 2)" << "\n";
197 }
198 else {
199 TopAbs_ShapeEnum Types[3] = {TopAbs_FACE, TopAbs_WIRE, TopAbs_EDGE};
200 TopoDS_Shape shape = DBRep::Get(argv[1]);
201 Standard_Real defl = atof(argv[3]);
202 Standard_Integer type = 1;
203 if(argc > 4) type = atoi(argv[4]);
204 type = Max(0, type);
205 type = Min(2, type);
206
207 Standard_Boolean ExtFace = Standard_False;
208 if(type == 0 || type == 2) ExtFace = Standard_True;
209 Standard_Boolean ExtEdge = Standard_False;
210 if(type == 1 || type == 2) ExtEdge = Standard_True;
211
212 VrmlData_Scene aScene;
213 VrmlData_ShapeConvert Conv(aScene);
214 Conv.AddShape(shape);
215 Conv.Convert(ExtFace, ExtEdge, defl);
216
217 filebuf foc;
218 ostream outStream (&foc);
219 if (foc.open (argv[2], ios::out))
9c6afe19 220 outStream << aScene;
7fd59977 221 }
222 return 0;
223}
224
225
226//-----------------------------------------------------------------------------
227static Standard_Integer createmesh
228(Draw_Interpretor& di, Standard_Integer argc, const char** argv )
229{
230
231 if (argc<3)
232 {
233 di << "Use: " << argv[0] << " <mesh name> <stl file>" << "\n";
234 return 1;
235 }
236
9c6afe19 237 // Progress indicator
7fd59977 238 OSD_Path aFile( argv[2] );
9c6afe19
RK
239 Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator (di, 1);
240 Handle(StlMesh_Mesh) aSTLMesh = RWStl::ReadFile (aFile, aProgress);
7fd59977 241
242 di << "Reading OK..." << "\n";
243 Handle( XSDRAWSTLVRML_DataSource ) aDS = new XSDRAWSTLVRML_DataSource( aSTLMesh );
244 di << "Data source is created successful" << "\n";
245 Handle( MeshVS_Mesh ) aMesh = new MeshVS_Mesh();
246 di << "MeshVS_Mesh is created successful" << "\n";
247
248 aMesh->SetDataSource( aDS );
249 aMesh->AddBuilder( new MeshVS_MeshPrsBuilder( aMesh.operator->() ), Standard_True );
250 // Prepare triangle labels
251 MeshVS_DataMapOfIntegerAsciiString aLabels;
252 Standard_Integer anIndex = 1, aLen = aSTLMesh->Triangles().Length();
253 for ( ; anIndex <= aLen; anIndex++ ){
254 aLabels.Bind( anIndex, TCollection_AsciiString( anIndex ) );
255 }
256
257 Handle(MeshVS_TextPrsBuilder) aTextBuilder = new MeshVS_TextPrsBuilder( aMesh.operator->(), 20., Quantity_NOC_YELLOW );
258 aTextBuilder->SetTexts( Standard_True, aLabels );
259 aMesh->AddBuilder( aTextBuilder );
260
261 // Hide all nodes by default
262 Handle(TColStd_HPackedMapOfInteger) aNodes = new TColStd_HPackedMapOfInteger();
263 aLen = aSTLMesh->Vertices().Length();
264 for ( anIndex = 1; anIndex <= aLen; anIndex++ )
265 aNodes->ChangeMap().Add( anIndex );
266 aMesh->SetHiddenNodes( aNodes );
267
268 Handle( AIS_InteractiveContext ) aContext = ViewerTest::GetAISContext();
269
270 if ( aContext.IsNull() )
271 {
9c6afe19 272 ViewerTest::ViewerInit();
7fd59977 273 //To create a 3D view if it doesn't exist
274 aContext = ViewerTest::GetAISContext();
275 if( aContext.IsNull() )
276 {
277 di << "Cannot create 3D view" << "\n";
278 return 0;
279 }
280 }
281
282 aContext->Display( aMesh );
283 aContext->Deactivate( aMesh );
284
285 Draw::Set( argv[1], new XSDRAWSTLVRML_DrawableMesh( aMesh ) );
286 Handle( V3d_View ) V = ViewerTest::CurrentView();
287 if ( !V.IsNull() )
288 V->FitAll();
289
290 return 0;
291}
292//-----------------------------------------------------------------------------
293Handle( MeshVS_Mesh ) getMesh( const char* name, Draw_Interpretor& di)
294{
295 Handle( XSDRAWSTLVRML_DrawableMesh ) aDrawMesh =
296 Handle( XSDRAWSTLVRML_DrawableMesh )::DownCast( Draw::Get( name ) );
297
298 if( aDrawMesh.IsNull() )
299 {
300 di << "There is no such object" << "\n";
301 return NULL;
302 }
303 else
304 {
305 Handle( MeshVS_Mesh ) aMesh = aDrawMesh->GetMesh();
306 if( aMesh.IsNull() )
307 {
308 di << "There is invalid mesh" << "\n";
309 return NULL;
310 }
311 else
312 return aMesh;
313 }
314}
315//-----------------------------------------------------------------------------
316static Standard_Integer meshdm
317(Draw_Interpretor& di, Standard_Integer argc, const char** argv )
318{
319 if (argc<3)
320 di << "wrong number of parameters" << "\n";
321 else
322 {
323 Handle( MeshVS_Mesh ) aMesh = getMesh( argv[1], di );
324 if( !aMesh.IsNull() )
325 {
326 Standard_Integer DisplayMode = 0;
327 sscanf( argv[2], "%i", &DisplayMode );
328
329 Handle( AIS_InteractiveContext ) aContext = ViewerTest::GetAISContext();
330
331 if( aContext.IsNull() )
332 di << "The context is null" << "\n";
333 else
334 {
335 Standard_Boolean HasLocal = aContext->HasOpenedContext();
336 if( HasLocal )
337 aContext->CloseLocalContext();
338
339 aContext->SetDisplayMode( aMesh, DisplayMode );
340 di << "Setting display mode: " << DisplayMode << "\n";
341
342 if( HasLocal )
343 aContext->OpenLocalContext();
344 }
345 }
346 }
347 return 0;
348}
349//-----------------------------------------------------------------------------
350static Standard_Integer meshsm
351(Draw_Interpretor& di, Standard_Integer argc, const char** argv )
352{
353 if (argc<3)
354 di << "wrong number of parameters" << "\n";
355 else
356 {
357 Handle( MeshVS_Mesh ) aMesh = getMesh( argv[1], di );
358 if( !aMesh.IsNull() )
359 {
360 Standard_Integer SelMode = 0;
361 sscanf( argv[2], "%i", &SelMode );
362
363 Handle( AIS_InteractiveContext ) aContext = ViewerTest::GetAISContext();
364
365 if( aContext.IsNull() )
366 di << "The context is null" << "\n";
367 else
368 {
369 if( !aContext->HasOpenedContext() )
370 aContext->OpenLocalContext();
371
372 aContext->Load( aMesh, -1 );
373
374 if( SelMode==-1 )
375 aContext->CloseAllContexts();
376
377 else if( SelMode==0 )
378 aContext->Activate( aMesh, 0 );
379
380 else if( SelMode>0 )
381 {
382 aContext->Deactivate( aMesh, 0 );
383
384 if( SelMode & 1 )
385 aContext->Activate( aMesh, 1 );
386 else
387 aContext->Deactivate( aMesh, 1 );
388
389 if( SelMode & 4 )
390 aContext->Activate( aMesh, 4 );
391 else
392 aContext->Deactivate( aMesh, 4 );
393
394 if( SelMode & 8 )
395 aContext->Activate( aMesh, 8 );
396 else
397 aContext->Deactivate( aMesh, 8 );
398 }
399
400 di << "Setting selection mode: " << SelMode << "\n";
401 }
402 }
403 }
404 return 0;
405}
406//-----------------------------------------------------------------------------
407static Standard_Integer setcolor
408(Draw_Interpretor& di, Standard_Integer argc, const char** argv, Standard_Integer Param )
409{
410 if (argc<5)
411 di << "wrong number of parameters" << "\n";
412 else
413 {
414 Handle( MeshVS_Mesh ) aMesh = getMesh( argv[1], di );
415 if( !aMesh.IsNull() )
416 {
417 Standard_Real r, g, b;
418 sscanf( argv[2], "%lf", &r );
419 sscanf( argv[3], "%lf", &g );
420 sscanf( argv[4], "%lf", &b );
421 aMesh->GetDrawer()->SetColor( (MeshVS_DrawerAttribute)Param, Quantity_Color( r, g, b, Quantity_TOC_RGB ) );
422
423 Handle( AIS_InteractiveContext ) aContext = ViewerTest::GetAISContext();
424
425 if( aContext.IsNull() )
426 di << "The context is null" << "\n";
427 else
428 aContext->Redisplay( aMesh );
429 }
430 }
431 return 0;
432}
433//-----------------------------------------------------------------------------
434static Standard_Integer meshcolor
435(Draw_Interpretor& interp, Standard_Integer argc, const char** argv )
436{
437 return setcolor( interp, argc, argv, MeshVS_DA_InteriorColor );
438}
439//-----------------------------------------------------------------------------
440static Standard_Integer linecolor
441(Draw_Interpretor& interp, Standard_Integer argc, const char** argv )
442{
443 return setcolor( interp, argc, argv, MeshVS_DA_EdgeColor );
444}
445//-----------------------------------------------------------------------------
446static Standard_Integer meshmat
447(Draw_Interpretor& di, Standard_Integer argc, const char** argv )
448{
449 if (argc<3)
450 di << "wrong number of parameters" << "\n";
451 else
452 {
453 Handle( MeshVS_Mesh ) aMesh = getMesh( argv[1], di );
454 if( !aMesh.IsNull() )
455 {
456 Standard_Integer mat;
457 sscanf( argv[2], "%i", &mat );
458
459 Graphic3d_MaterialAspect aMatAsp =
460 (Graphic3d_MaterialAspect)(Graphic3d_NameOfMaterial)mat;
461
462 aMesh->GetDrawer()->SetMaterial( MeshVS_DA_FrontMaterial, aMatAsp );
463 aMesh->GetDrawer()->SetMaterial( MeshVS_DA_BackMaterial, aMatAsp );
464
465 Handle( AIS_InteractiveContext ) aContext = ViewerTest::GetAISContext();
466
467 if( aContext.IsNull() )
468 di << "The context is null" << "\n";
469 else
470 aContext->Redisplay( aMesh );
471 }
472 }
473 return 0;
474}
475//-----------------------------------------------------------------------------
476static Standard_Integer shrink
477(Draw_Interpretor& di, Standard_Integer argc, const char** argv )
478{
479 if (argc<3)
480 di << "wrong number of parameters" << "\n";
481 else
482 {
483 Handle( MeshVS_Mesh ) aMesh = getMesh( argv[1], di );
484 if( !aMesh.IsNull() )
485 {
486 Standard_Real sh;
487 sscanf( argv[2], "%lf", &sh );
488 aMesh->GetDrawer()->SetDouble( MeshVS_DA_ShrinkCoeff, sh );
489
490 Handle( AIS_InteractiveContext ) aContext = ViewerTest::GetAISContext();
491
492 if( aContext.IsNull() )
493 di << "The context is null" << "\n";
494 else
495 aContext->Redisplay( aMesh );
496 }
497 }
498 return 0;
499}
500//-----------------------------------------------------------------------------
501
502static Standard_Integer mdisplay
503(Draw_Interpretor& di, Standard_Integer argc, const char** argv )
504{
505 if (argc<2)
506 di << "wrong number of parameters" << "\n";
507 else
508 {
509 Handle( MeshVS_Mesh ) aMesh = getMesh( argv[1], di );
510 if( !aMesh.IsNull() )
511 {
512 Handle( AIS_InteractiveContext ) aContext = ViewerTest::GetAISContext();
513
514 if( aContext.IsNull() )
515 di << "The context is null" << "\n";
516 else
517 {
518 if( aContext->HasOpenedContext() )
519 aContext->CloseLocalContext();
520
521 aContext->Display( aMesh );
522 }
523 }
524 }
525 return 0;
526}
527//-----------------------------------------------------------------------------
528static Standard_Integer merase
529(Draw_Interpretor& di, Standard_Integer argc, const char** argv )
530{
531 if (argc<2)
532 di << "wrong number of parameters" << "\n";
533 else
534 {
535 Handle( MeshVS_Mesh ) aMesh = getMesh( argv[1], di );
536 if( !aMesh.IsNull() )
537 {
538 Handle( AIS_InteractiveContext ) aContext = ViewerTest::GetAISContext();
539
540 if( aContext.IsNull() )
541 di << "The context is null" << "\n";
542 else
543 {
544 if( aContext->HasOpenedContext() )
545 aContext->CloseLocalContext();
546
547 aContext->Erase( aMesh );
548 }
549 }
550 else
551 di << "Mesh is null" << "\n";
552 }
553 return 0;
554}
555//-----------------------------------------------------------------------------
556static Standard_Integer hidesel
557(Draw_Interpretor& di, Standard_Integer argc, const char** argv )
558{
559 if (argc<1)
560 {
561 di << "wrong number of parameters" << "\n";
562 return 0;
563 }
564
565
566 Handle( AIS_InteractiveContext ) aContext = ViewerTest::GetAISContext();
567 Handle( MeshVS_Mesh ) aMesh = getMesh( argv[1], di );
568 if( aMesh.IsNull() )
569 {
570 di << "The mesh is invalid" << "\n";
571 return 0;
572 }
573
574 if( aContext.IsNull() )
575 di << "The context is null" << "\n";
576 else
577 {
578 Handle(TColStd_HPackedMapOfInteger) aHiddenNodes = aMesh->GetHiddenNodes();
579 Handle(TColStd_HPackedMapOfInteger) aHiddenElements = aMesh->GetHiddenElems();
580 for( aContext->InitSelected(); aContext->MoreSelected(); aContext->NextSelected() )
581 {
582 Handle( MeshVS_MeshEntityOwner ) anOwner =
583 Handle( MeshVS_MeshEntityOwner )::DownCast( aContext->SelectedOwner() );
584 if( !anOwner.IsNull() )
585 if( anOwner->Type()==MeshVS_ET_Node )
586 aHiddenNodes->ChangeMap().Add( anOwner->ID() );
587 else
588 aHiddenElements->ChangeMap().Add( anOwner->ID() );
589 }
590 aContext->ClearSelected();
591 aMesh->SetHiddenNodes( aHiddenNodes );
592 aMesh->SetHiddenElems( aHiddenElements );
593 aContext->Redisplay( aMesh );
594 }
595
596 return 0;
597}
598//-----------------------------------------------------------------------------
599static Standard_Integer showonly
600(Draw_Interpretor& di, Standard_Integer argc, const char** argv )
601{
602 if (argc<1)
603 {
604 di << "wrong number of parameters" << "\n";
605 return 0;
606 }
607
608
609 Handle( AIS_InteractiveContext ) aContext = ViewerTest::GetAISContext();
610 Handle( MeshVS_Mesh ) aMesh = getMesh( argv[1], di );
611 if( aMesh.IsNull() )
612 {
613 di << "The mesh is invalid" << "\n";
614 return 0;
615 }
616
617 if( aContext.IsNull() )
618 di << "The context is null" << "\n";
619 else
620 {
9c6afe19 621 Handle(TColStd_HPackedMapOfInteger) aHiddenNodes =
7fd59977 622 new TColStd_HPackedMapOfInteger(aMesh->GetDataSource()->GetAllNodes());
9c6afe19 623 Handle(TColStd_HPackedMapOfInteger) aHiddenElements =
7fd59977 624 new TColStd_HPackedMapOfInteger(aMesh->GetDataSource()->GetAllElements());
625 for( aContext->InitSelected(); aContext->MoreSelected(); aContext->NextSelected() )
626 {
627 Handle( MeshVS_MeshEntityOwner ) anOwner =
628 Handle( MeshVS_MeshEntityOwner )::DownCast( aContext->SelectedOwner() );
629 if( !anOwner.IsNull() )
630 if( anOwner->Type()==MeshVS_ET_Node )
631 aHiddenNodes->ChangeMap().Remove( anOwner->ID() );
632 else
633 aHiddenElements->ChangeMap().Remove( anOwner->ID() );
634 }
635 aMesh->SetHiddenNodes( aHiddenNodes );
636 aMesh->SetHiddenElems( aHiddenElements );
637 aContext->Redisplay( aMesh );
638 }
639
640 return 0;
641}
642//-----------------------------------------------------------------------------
643static Standard_Integer showall
644(Draw_Interpretor& di, Standard_Integer argc, const char** argv )
645{
646 if (argc<1)
647 {
648 di << "wrong number of parameters" << "\n";
649 return 0;
650 }
651
652 Handle( AIS_InteractiveContext ) aContext = ViewerTest::GetAISContext();
653 Handle( MeshVS_Mesh ) aMesh = getMesh( argv[1], di );
654 if( aMesh.IsNull() )
655 {
656 di << "The mesh is invalid" << "\n";
657 return 0;
658 }
659
660 if( aContext.IsNull() )
661 di << "The context is null" << "\n";
662 else
663 {
664 aMesh->SetHiddenNodes( 0 );
665 aMesh->SetHiddenElems( 0 );
666 aContext->Redisplay( aMesh );
667 }
668
669 return 0;
670}
671//-----------------------------------------------------------------------------
672static Standard_Integer delmesh
673(Draw_Interpretor& di, Standard_Integer argc, const char** argv )
674{
675 if (argc<2)
676 {
677 di << "wrong number of parameters" << "\n";
678 return 0;
679 }
680
681 Handle( MeshVS_Mesh ) aMesh = getMesh( argv[1], di );
682
683 if( aMesh.IsNull() )
684 {
685 di << "The mesh is invalid" << "\n";
686 return 0;
687 }
688 else
689 {
690 Handle( AIS_InteractiveContext ) aContext = ViewerTest::GetAISContext();
691
692 aContext->ClearSelected();
693
694 if( aContext->HasOpenedContext() )
695 aContext->CloseAllContexts();
696
697 aContext->Remove( aMesh );
698 aContext->SelectionManager()->Remove( aMesh );
699 aMesh->ClearSelections();
700 aContext->MainSelector()->Clear();
701
702 Draw::Set( argv[1], Handle(XSDRAWSTLVRML_DrawableMesh)() );
703
704 Standard::Purge();
705 }
706 return 0;
707}
708//-----------------------------------------------------------------------------
709
9c6afe19
RK
710static Standard_Integer meshcolors( Draw_Interpretor& di,
711 Standard_Integer argc,
7fd59977 712 const char** argv )
713{
714 try
715 {
716 OCC_CATCH_SIGNALS
717 if ( argc < 2 )
718 {
719 di << "Use : meshcolors meshname mode isreflect" << "\n";
3ba3388b 720 di << "mode : {elem1|elem2|nodal|nodaltex|none}"<< "\n";
7fd59977 721 di << " elem1 - different color for each element" << "\n";
722 di << " elem2 - one color for one side"<<"\n";
3ba3388b
A
723 di << " nodal - different color for each node"<< "\n";
724 di << " nodaltex - different color for each node with texture interpolation"<< "\n";
9c6afe19 725 di << " none - clear"<< "\n";
7fd59977 726 di << "isreflect : {0|1} "<< "\n";
9c6afe19 727
7fd59977 728 return 0;
729 }
730
731 Handle( MeshVS_Mesh ) aMesh = getMesh( argv[ 1 ], di );
732
733 if ( aMesh.IsNull() )
734 {
735 di << "Mesh not found" << "\n";
736 return 0;
737 }
738 Handle(AIS_InteractiveContext) anIC = ViewerTest::GetAISContext();
739 if ( anIC.IsNull() )
740 {
741 di << "The context is null" << "\n";
742 return 0;
743 }
744 if( !aMesh.IsNull() )
745 {
746 TCollection_AsciiString aMode = TCollection_AsciiString (argv[2]);
747 Quantity_Color aColor1( (Quantity_NameOfColor)( Quantity_NOC_BLUE1 ) );
748 Quantity_Color aColor2( (Quantity_NameOfColor)( Quantity_NOC_RED1 ) );
3ba3388b 749 if( aMode.IsEqual("elem1") || aMode.IsEqual("elem2") || aMode.IsEqual("nodal") || aMode.IsEqual("nodaltex") || aMode.IsEqual("none") )
7fd59977 750 {
751 Handle(MeshVS_PrsBuilder) aTempBuilder;
752 Standard_Integer reflection = atoi(argv[3]);
753
754 for (int count = 0 ; count < aMesh->GetBuildersCount(); count++ ){
755 aTempBuilder = Handle(MeshVS_PrsBuilder)::DownCast(aMesh->FindBuilder("MeshVS_ElementalColorPrsBuilder"));
756 if( !aTempBuilder.IsNull())
757 aMesh->RemoveBuilderById(aTempBuilder->GetId());
758
759 aTempBuilder = Handle(MeshVS_PrsBuilder)::DownCast(aMesh->FindBuilder("MeshVS_NodalColorPrsBuilder"));
760 if( !aTempBuilder.IsNull())
761 aMesh->RemoveBuilderById(aTempBuilder->GetId());
762 }
763
764 if( aMode.IsEqual("elem1") || aMode.IsEqual("elem2") )
765 {
9c6afe19 766 Handle(MeshVS_ElementalColorPrsBuilder) aBuilder = new MeshVS_ElementalColorPrsBuilder(
7fd59977 767 aMesh, MeshVS_DMF_ElementalColorDataPrs | MeshVS_DMF_OCCMask );
768 // Color
769 const TColStd_PackedMapOfInteger& anAllElements = aMesh->GetDataSource()->GetAllElements();
770 TColStd_MapIteratorOfPackedMapOfInteger anIter( anAllElements );
771
772 if( aMode.IsEqual("elem1") )
773 for ( ; anIter.More(); anIter.Next() )
774 {
775 Quantity_Color aColor( (Quantity_NameOfColor)( anIter.Key() % Quantity_NOC_WHITE ) );
776 aBuilder->SetColor1( anIter.Key(), aColor );
777 }
778 else
779 for ( ; anIter.More(); anIter.Next() )
780 aBuilder->SetColor2( anIter.Key(), aColor1, aColor2 );
781
782 aMesh->AddBuilder( aBuilder, Standard_True );
783 }
784
9c6afe19 785
7fd59977 786 if( aMode.IsEqual("nodal") )
787 {
9c6afe19 788 Handle(MeshVS_NodalColorPrsBuilder) aBuilder = new MeshVS_NodalColorPrsBuilder(
7fd59977 789 aMesh, MeshVS_DMF_NodalColorDataPrs | MeshVS_DMF_OCCMask );
790 aMesh->AddBuilder( aBuilder, Standard_True );
791
792 // Color
793 const TColStd_PackedMapOfInteger& anAllNodes =
794 aMesh->GetDataSource()->GetAllNodes();
795 TColStd_MapIteratorOfPackedMapOfInteger anIter( anAllNodes );
796 for ( ; anIter.More(); anIter.Next() )
797 {
9c6afe19 798 Quantity_Color aColor( (Quantity_NameOfColor)(
7fd59977 799 anIter.Key() % Quantity_NOC_WHITE ) );
800 aBuilder->SetColor( anIter.Key(), aColor );
801 }
802 aMesh->AddBuilder( aBuilder, Standard_True );
803 }
804
3ba3388b
A
805 if(aMode.IsEqual("nodaltex"))
806 {
807 // assign nodal builder to the mesh
9c6afe19 808 Handle(MeshVS_NodalColorPrsBuilder) aBuilder = new MeshVS_NodalColorPrsBuilder(
3ba3388b
A
809 aMesh, MeshVS_DMF_NodalColorDataPrs | MeshVS_DMF_OCCMask);
810 aMesh->AddBuilder(aBuilder, Standard_True);
811 aBuilder->UseTexture(Standard_True);
812
813 // prepare color map for texture
814 Aspect_SequenceOfColor aColorMap;
815 aColorMap.Append((Quantity_NameOfColor) Quantity_NOC_RED);
816 aColorMap.Append((Quantity_NameOfColor) Quantity_NOC_YELLOW);
817 aColorMap.Append((Quantity_NameOfColor) Quantity_NOC_BLUE1);
818
819 // prepare scale map for mesh - it will be assigned to mesh as texture coordinates
820 // make mesh color interpolated from minimum X coord to maximum X coord
821 Handle(MeshVS_DataSource) aDataSource = aMesh->GetDataSource();
822 Standard_Real aMinX, aMinY, aMinZ, aMaxX, aMaxY, aMaxZ;
823
824 // get bounding box for calculations
825 aDataSource->GetBoundingBox().Get(aMinX, aMinY, aMinZ, aMaxX, aMaxY, aMaxZ);
826 Standard_Real aDelta = aMaxX - aMinX;
827
828 // assign color scale map values (0..1) to nodes
829 TColStd_DataMapOfIntegerReal aScaleMap;
830 TColStd_Array1OfReal aCoords(1, 3);
831 Standard_Integer aNbNodes;
832 MeshVS_EntityType aType;
833
834 // iterate nodes
835 const TColStd_PackedMapOfInteger& anAllNodes =
836 aMesh->GetDataSource()->GetAllNodes();
837 TColStd_MapIteratorOfPackedMapOfInteger anIter(anAllNodes);
838 for (; anIter.More(); anIter.Next())
839 {
840 //get node coordinates to aCoord variable
841 aDataSource->GetGeom(anIter.Key(), Standard_False, aCoords, aNbNodes, aType);
842
843 Standard_Real aScaleValue;
844 try {
845 OCC_CATCH_SIGNALS
846 aScaleValue = (aCoords.Value(1) - (Standard_Real) aMinX) / aDelta;
847 } catch(Standard_Failure) {
848 aScaleValue = 0;
849 }
850
9c6afe19 851 aScaleMap.Bind(anIter.Key(), aScaleValue);
3ba3388b
A
852 }
853
854 //set color map for builder and a color for invalid scale value
855 aBuilder->SetColorMap(aColorMap);
856 aBuilder->SetInvalidColor(Quantity_NOC_BLACK);
857 aBuilder->SetTextureCoords(aScaleMap);
858 aMesh->AddBuilder(aBuilder, Standard_True);
9c6afe19 859
3ba3388b
A
860 //set viewer to display texures
861 const Handle(V3d_Viewer)& aViewer = anIC->CurrentViewer();
862 for (aViewer->InitActiveViews(); aViewer->MoreActiveViews(); aViewer->NextActiveViews())
863 aViewer->ActiveView()->SetSurfaceDetail(V3d_TEX_ALL);
864 }
865
7fd59977 866 aMesh->GetDrawer()->SetBoolean ( MeshVS_DA_ColorReflection, Standard_Boolean(reflection) );
867
868 anIC->Redisplay( aMesh );
869 }
870 else
9c6afe19 871 {
7fd59977 872 di << "Wrong mode name" << "\n";
873 return 0;
874 }
875 }
876 }
877 catch ( Standard_Failure )
878 {
879 di << "Error" << "\n";
880 }
881
882 return 0;
883}
884//-----------------------------------------------------------------------------
885
9c6afe19
RK
886static Standard_Integer mesh_edge_width( Draw_Interpretor& di,
887 Standard_Integer argc,
7fd59977 888 const char** argv )
889{
890 try
891 {
892 OCC_CATCH_SIGNALS
893 if ( argc < 3 )
894 {
895 di << "Wrong number of parameters. Use : mesh_edge_width mesh width" << "\n";
896 return 0;
897 }
898
899 Handle(MeshVS_Mesh) aMesh = getMesh( argv[ 1 ], di );
900 if ( aMesh.IsNull() )
901 {
902 di << "Mesh not found" << "\n";
903 return 0;
904 }
905
906 const char* aWidthStr = argv[ 2 ];
907 if ( aWidthStr == 0 || atof( aWidthStr ) <= 0 )
908 {
909 di << "Width must be real value more than zero" << "\n";
910 return 0;
911 }
912
913 double aWidth = atof( aWidthStr );
914
915 Handle(AIS_InteractiveContext) anIC = ViewerTest::GetAISContext();
916 if ( anIC.IsNull() )
917 {
918 di << "The context is null" << "\n";
919 return 0;
920 }
921
922 Handle(MeshVS_Drawer) aDrawer = aMesh->GetDrawer();
923 if ( aDrawer.IsNull() )
924 {
925 di << "The drawer is null" << "\n";
926 return 0;
927 }
928
929 aDrawer->SetDouble( MeshVS_DA_EdgeWidth, aWidth );
930 anIC->Redisplay( aMesh );
931 }
932 catch ( Standard_Failure )
933 {
934 di << "Error" << "\n";
935 }
936
937 return 0;
938}
939
940//-----------------------------------------------------------------------------
941
942void XSDRAWSTLVRML::InitCommands (Draw_Interpretor& theCommands)
943{
944 const char* g = "XSTEP-STL/VRML"; // Step transfer file commands
945 //XSDRAW::LoadDraw(theCommands);
946
947 theCommands.Add ("writevrml", "shape file",__FILE__,writevrml,g);
948 theCommands.Add ("writestl", "shape file",__FILE__,writestl,g);
949 theCommands.Add ("readstl", "shape file",__FILE__,readstl,g);
950 theCommands.Add ("loadvrml" , "shape file",__FILE__,loadvrml,g);
951 theCommands.Add ("storevrml" , "shape file defl [type]",__FILE__,storevrml,g);
952
953 theCommands.Add ("meshfromstl", "creates MeshVS_Mesh from STL file", __FILE__, createmesh, g );
954 theCommands.Add ("meshdispmode", "changes MeshVS_Mesh display mode", __FILE__, meshdm, g );
955 theCommands.Add ("meshselmode", "changes MeshVS_Mesh selection mode", __FILE__, meshsm, g );
956 theCommands.Add ("meshshadcolor", "change MeshVS_Mesh shading color", __FILE__, meshcolor, g );
957 theCommands.Add ("meshlinkcolor", "change MeshVS_Mesh line color", __FILE__, linecolor, g );
958 theCommands.Add ("meshmat", "change MeshVS_Mesh material", __FILE__, meshmat, g );
959 theCommands.Add ("meshshrcoef", "change MeshVS_Mesh shrink coeff", __FILE__, shrink, g );
960 theCommands.Add ("meshshow", "display MeshVS_Mesh object", __FILE__, mdisplay, g );
961 theCommands.Add ("meshhide", "erase MeshVS_Mesh object", __FILE__, merase, g );
962 theCommands.Add ("meshhidesel", "hide selected entities", __FILE__, hidesel, g );
963 theCommands.Add ("meshshowsel", "show only selected entities", __FILE__, showonly, g );
964 theCommands.Add ("meshshowall", "show all entities", __FILE__, showall, g );
965 theCommands.Add ("meshdelete", "delete MeshVS_Mesh object", __FILE__, delmesh, g );
966 theCommands.Add ("meshcolors", "display color presentation", __FILE__, meshcolors, g );
967 theCommands.Add ("mesh_edge_width", "set width of edges", __FILE__, mesh_edge_width, g );
968}
969
970//==============================================================================
971// XSDRAWSTLVRML::Factory
972//==============================================================================
973void XSDRAWSTLVRML::Factory(Draw_Interpretor& theDI)
974{
975 XSDRAWIGES::InitSelect();
976 XSDRAWIGES::InitToBRep(theDI);
977 XSDRAWIGES::InitFromBRep(theDI);
978 XSDRAWSTEP::InitCommands(theDI);
979 XSDRAWSTLVRML::InitCommands(theDI);
980 SWDRAW::Init(theDI);
981 XSDRAW::LoadDraw(theDI);
982#ifdef DEB
983 theDI << "Draw Plugin : All TKXSDRAW commands are loaded" << "\n";
984#endif
985}
986
987// Declare entry point PLUGINFACTORY
988DPLUGIN(XSDRAWSTLVRML)
989