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