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