# MedicalDemo4

VTKExamples/Cxx/Medical/MedicalDemo4

### Description

Volume rendering of the dataset.

Usage

MedicalDemo4 FullHead.mhd

Info

The example uses FullHead.mhd which references FullHead.raw.gz.

Note

This original source code for this example is here.

Other Languages

See (Python)

### Code

MedicalDemo4.cxx

    // Derived from VTK/Examples/Cxx/Medical4.cxx
    // This example reads a volume dataset and displays it via volume rendering.
    //

    #include <vtkCamera.h>
    #include <vtkColorTransferFunction.h>
    #include <vtkFixedPointVolumeRayCastMapper.h>
    #include <vtkMetaImageReader.h>
    #include <vtkNamedColors.h>
    #include <vtkPiecewiseFunction.h>
    #include <vtkRenderer.h>
    #include <vtkRenderWindow.h>
    #include <vtkRenderWindowInteractor.h>
    #include <vtkSmartPointer.h>
    #include <vtkVolume.h>
    #include <vtkVolumeProperty.h>

    #include <array>

    int main (int argc, char *argv[])
    {
      if (argc < 2)
      {
        cout << "Usage: " << argv[0] << "file.mhd" << endl;
        return EXIT_FAILURE;
      }

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

      std::array<unsigned char , 4> bkg{{51, 77, 102, 255}};
        colors->SetColor("BkgColor", bkg.data());

      // Create the renderer, the render window, and the interactor. The renderer
      // draws into the render window, the interactor enables mouse- and
      // keyboard-based interaction with the scene.
      vtkSmartPointer<vtkRenderer> ren =
        vtkSmartPointer<vtkRenderer>::New();
      vtkSmartPointer<vtkRenderWindow> renWin =
        vtkSmartPointer<vtkRenderWindow>::New();
      renWin->AddRenderer(ren);
      vtkSmartPointer<vtkRenderWindowInteractor> iren =
        vtkSmartPointer<vtkRenderWindowInteractor>::New();
      iren->SetRenderWindow(renWin);

      // The following reader is used to read a series of 2D slices (images)
      // that compose the volume. The slice dimensions are set, and the
      // pixel spacing. The data Endianness must also be specified. The reader
      // uses the FilePrefix in combination with the slice number to construct
      // filenames using the format FilePrefix.%d. (In this case the FilePrefix
      // is the root name of the file: quarter.)
      vtkSmartPointer<vtkMetaImageReader> reader =
        vtkSmartPointer<vtkMetaImageReader>::New();
      reader->SetFileName(argv[1]);

      // The volume will be displayed by ray-cast alpha compositing.
      // A ray-cast mapper is needed to do the ray-casting.
      vtkSmartPointer<vtkFixedPointVolumeRayCastMapper> volumeMapper =
        vtkSmartPointer<vtkFixedPointVolumeRayCastMapper>::New();
      volumeMapper->SetInputConnection(reader->GetOutputPort());

      // The color transfer function maps voxel intensities to colors.
      // It is modality-specific, and often anatomy-specific as well.
      // The goal is to one color for flesh (between 500 and 1000)
      // and another color for bone (1150 and over).
      vtkSmartPointer<vtkColorTransferFunction>volumeColor =
        vtkSmartPointer<vtkColorTransferFunction>::New();
      volumeColor->AddRGBPoint(0,    0.0, 0.0, 0.0);
      volumeColor->AddRGBPoint(500,  1.0, 0.5, 0.3);
      volumeColor->AddRGBPoint(1000, 1.0, 0.5, 0.3);
      volumeColor->AddRGBPoint(1150, 1.0, 1.0, 0.9);

      // The opacity transfer function is used to control the opacity
      // of different tissue types.
      vtkSmartPointer<vtkPiecewiseFunction> volumeScalarOpacity =
        vtkSmartPointer<vtkPiecewiseFunction>::New();
      volumeScalarOpacity->AddPoint(0,    0.00);
      volumeScalarOpacity->AddPoint(500,  0.15);
      volumeScalarOpacity->AddPoint(1000, 0.15);
      volumeScalarOpacity->AddPoint(1150, 0.85);

      // The gradient opacity function is used to decrease the opacity
      // in the "flat" regions of the volume while maintaining the opacity
      // at the boundaries between tissue types.  The gradient is measured
      // as the amount by which the intensity changes over unit distance.
      // For most medical data, the unit distance is 1mm.
      vtkSmartPointer<vtkPiecewiseFunction> volumeGradientOpacity =
        vtkSmartPointer<vtkPiecewiseFunction>::New();
      volumeGradientOpacity->AddPoint(0,   0.0);
      volumeGradientOpacity->AddPoint(90,  0.5);
      volumeGradientOpacity->AddPoint(100, 1.0);

      // The VolumeProperty attaches the color and opacity functions to the
      // volume, and sets other volume properties.  The interpolation should
      // be set to linear to do a high-quality rendering.  The ShadeOn option
      // turns on directional lighting, which will usually enhance the
      // appearance of the volume and make it look more "3D".  However,
      // the quality of the shading depends on how accurately the gradient
      // of the volume can be calculated, and for noisy data the gradient
      // estimation will be very poor.  The impact of the shading can be
      // decreased by increasing the Ambient coefficient while decreasing
      // the Diffuse and Specular coefficient.  To increase the impact
      // of shading, decrease the Ambient and increase the Diffuse and Specular.
      vtkSmartPointer<vtkVolumeProperty> volumeProperty =
        vtkSmartPointer<vtkVolumeProperty>::New();
      volumeProperty->SetColor(volumeColor);
      volumeProperty->SetScalarOpacity(volumeScalarOpacity);
      volumeProperty->SetGradientOpacity(volumeGradientOpacity);
      volumeProperty->SetInterpolationTypeToLinear();
      volumeProperty->ShadeOn();
      volumeProperty->SetAmbient(0.4);
      volumeProperty->SetDiffuse(0.6);
      volumeProperty->SetSpecular(0.2);

      // The vtkVolume is a vtkProp3D (like a vtkActor) and controls the position
      // and orientation of the volume in world coordinates.
      vtkSmartPointer<vtkVolume> volume =
        vtkSmartPointer<vtkVolume>::New();
      volume->SetMapper(volumeMapper);
      volume->SetProperty(volumeProperty);

      // Finally, add the volume to the renderer
      ren->AddViewProp(volume);

      // Set up an initial view of the volume.  The focal point will be the
      // center of the volume, and the camera position will be 400mm to the
      // patient's left (which is our right).
      vtkCamera *camera = ren->GetActiveCamera();
      double *c = volume->GetCenter();
      camera->SetViewUp (0, 0, -1);
      camera->SetPosition (c[0], c[1] - 400, c[2]);
      camera->SetFocalPoint (c[0], c[1], c[2]);
      camera->Azimuth(30.0);
      camera->Elevation(30.0);

      // Set a background color for the renderer
      ren->SetBackground(colors->GetColor3d("BkgColor").GetData());

      // Increase the size of the render window
      renWin->SetSize(640, 480);

      // Interact with the data.
      iren->Start();

      return EXIT_SUCCESS;
    }

### CMakeLists.txt

    cmake_minimum_required(VERSION 3.3 FATAL_ERROR)

    project(MedicalDemo4)

    find_package(VTK COMPONENTS
      vtkCommonColor
      vtkCommonCore
      vtkCommonDataModel
      vtkIOImage
      vtkInteractionStyle
      vtkRenderingCore
      vtkRenderingFreeType
      vtkRenderingOpenGL2
      vtkRenderingVolume
      vtkRenderingVolumeOpenGL2 QUIET)
    if (NOT VTK_FOUND)
      message("Skipping MedicalDemo4: ${VTK_NOT_FOUND_MESSAGE}")
      return ()
    endif()
    message (STATUS "VTK_VERSION: ${VTK_VERSION}")
    if (VTK_VERSION VERSION_LESS "8.90.0")
      # old system
      include(${VTK_USE_FILE})
      add_executable(MedicalDemo4 MACOSX_BUNDLE MedicalDemo4.cxx )
      target_link_libraries(MedicalDemo4 PRIVATE ${VTK_LIBRARIES})
    else ()
      # include all components
      add_executable(MedicalDemo4 MACOSX_BUNDLE MedicalDemo4.cxx )
      target_link_libraries(MedicalDemo4 PRIVATE ${VTK_LIBRARIES})
      # vtk_module_autoinit is needed
      vtk_module_autoinit(
        TARGETS MedicalDemo4
        MODULES ${VTK_LIBRARIES}
        )
    endif ()

### Download and Build MedicalDemo4

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

    cd MedicalDemo4/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:

    ./MedicalDemo4

WINDOWS USERS

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