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