src/XSDRAWSTLVRML/XSDRAWSTLVRML.cxx

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