# VRMLImporterDemo

VTKExamples/Cxx/IO/VRMLImporterDemo

### Description

vtkVRMLImporter imports multiple vtkActor models. Sometimes the vtkPolyData require modifications. For example the data in this example does not have normals. The example uses vtkActorCollection to walk each model's vtkPolyData and inserts a vtkPolyDataNormals if the normals do not exist.

Warning

vtkVRMLImporter files use a shininess between 0 and 1, while vtk's vtkProperty has a specular power between 0 and 128. The example corrects this if the specular power is <= 1.0.

Warning

vtkVRMLImporter incorrectly creates a vtkLookupTable for colorPerVertex. This example converts the vtkLookupTable to vtkPointData.

Tip

The Virtual Insect website has lots of cool wrl models of insects.

### Code

VRMLImporterDemo.cxx

    #include <vtkSmartPointer.h>
    #include <vtkVRMLImporter.h>

    #include <vtkUnsignedCharArray.h>
    #include <vtkActor.h>
    #include <vtkActorCollection.h>
    #include <vtkCamera.h>
    #include <vtkMapper.h>
    #include <vtkLookupTable.h>
    #include <vtkPointData.h>
    #include <vtkPolyData.h>
    #include <vtkPolyDataMapper.h>
    #include <vtkPolyDataNormals.h>
    #include <vtkProperty.h>
    #include <vtkRenderWindow.h>
    #include <vtkRenderWindowInteractor.h>
    #include <vtkRenderer.h>

    #include <vtkNamedColors.h>

    int main ( int argc, char *argv[])
    {
      if(argc < 2)
      {
        std::cout << "Required arguments: Filename" << std::endl;
        return EXIT_FAILURE;
      }

      std::string filename = argv[1];
      std::cout << "Reading " << filename << std::endl;

      vtkSmartPointer<vtkNamedColors> colors =
        vtkSmartPointer<vtkNamedColors>::New();

      vtkSmartPointer<vtkRenderer> renderer =
        vtkSmartPointer<vtkRenderer>::New();
      vtkSmartPointer<vtkRenderWindow> renderWindow =
        vtkSmartPointer<vtkRenderWindow>::New();
      renderWindow->AddRenderer(renderer);

      vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
        vtkSmartPointer<vtkRenderWindowInteractor>::New();
      renderWindowInteractor->SetRenderWindow(renderWindow);

      // VRML Import
      vtkSmartPointer<vtkVRMLImporter> importer =
        vtkSmartPointer<vtkVRMLImporter>::New();
      importer->SetFileName ( filename.c_str() );
      importer->SetRenderWindow(renderWindow);
      importer->Update();

      vtkSmartPointer<vtkActorCollection> actors =
        vtkSmartPointer<vtkActorCollection>::New();
      actors = renderer->GetActors();
      std::cout << "There are " << actors->GetNumberOfItems() << " actors" << std::endl;
      int m = 0;
      actors->InitTraversal();
      for (vtkIdType a = 0; a < actors->GetNumberOfItems(); ++a)
      {
        vtkActor * actor = actors->GetNextActor();

        // The importer shininess parameter is between 0 and 1. VTK specular power is usually 10-100.
        // Also, the default for the specular factor for VRML is 1, while VTK's is 0
        double specularPower = actor->GetProperty()->GetSpecularPower();
        if (specularPower <= 1.0)
        {
          actor->GetProperty()->SetSpecularPower(specularPower * 128.0);
        }
        double specular = actor->GetProperty()->GetSpecular();
        if (specular == 0.0)
        {
          actor->GetProperty()->SetSpecular(1.0);
        }
        // The VRML default ambient intensity is .2
        double ambientIntensity = actor->GetProperty()->GetAmbient();
    #if 0
        if (ambientIntensity == 0.0)
        {
          actor->GetProperty()->SetAmbient(.2);
        }
    #endif
        vtkPolyDataMapper *mapper = vtkPolyDataMapper::SafeDownCast(actor->GetMapper());
        if (mapper)
        {
          vtkPolyData *dataSet = vtkPolyData::SafeDownCast(mapper->GetInput());
          if (!dataSet->GetPointData()->GetNormals())
          {
            vtkSmartPointer<vtkPolyDataNormals> normals =
              vtkSmartPointer<vtkPolyDataNormals>::New();
            normals->SetInputData(dataSet);
            normals->SplittingOff();
            normals->Update();
            mapper->SetInputData(normals->GetOutput());
          }

          // If there is a lookup table, convert it to point data
          vtkLookupTable *lut = vtkLookupTable::SafeDownCast(mapper->GetLookupTable());
          if (lut && mapper->GetScalarVisibility())
          {
            vtkSmartPointer<vtkUnsignedCharArray> pc =
              vtkSmartPointer<vtkUnsignedCharArray>::New();
            pc->SetNumberOfComponents(4);
            pc->SetNumberOfTuples(lut->GetNumberOfColors());
            for (int t = 0; t < lut->GetNumberOfColors(); ++t)
            {
              double *lutc = lut->GetTableValue(t);
              unsigned char lutuc[4];
              lut->GetColorAsUnsignedChars(lutc, lutuc);
              pc->SetTypedTuple(t, lutuc);
            }
            mapper->SetLookupTable(NULL);
            mapper->GetInput()->GetPointData()->SetScalars(pc);
          }
        }
      }

      renderer->ResetCamera();
      renderer->GetActiveCamera()->Azimuth(30);
      renderer->GetActiveCamera()->Elevation(30);
      renderer->GetActiveCamera()->Dolly(1.4);
      renderer->ResetCameraClippingRange();

      renderer->SetBackground(colors->GetColor3d("PaleGreen").GetData());
      renderWindow->SetSize(640, 480);
      renderWindow->Render();
      renderWindowInteractor->Start();

      return EXIT_SUCCESS;
    }

### CMakeLists.txt

    cmake_minimum_required(VERSION 2.8)

    PROJECT(VRMLImporterDemo)

    find_package(VTK REQUIRED)
    include(${VTK_USE_FILE})

    add_executable(VRMLImporterDemo MACOSX_BUNDLE VRMLImporterDemo.cxx )

    target_link_libraries(VRMLImporterDemo ${VTK_LIBRARIES})

### Download and Build VRMLImporterDemo

Click here to download VRMLImporterDemo and its CMakeLists.txt file. Once the tarball VRMLImporterDemo.tar has been downloaded and extracted,

    cd VRMLImporterDemo/build

If VTK is installed:

    cmake ..

If VTK is not installed but compiled on your system, you will need to specify the path to your VTK build:

    cmake -DVTK_DIR:PATH=/home/me/vtk_build ..

Build the project:

    make

and run it:

    ./VRMLImporterDemo

WINDOWS USERS PLEASE NOTE: Be sure to add the VTK bin directory to your path. This will resolve the VTK dll's at run time.