VTK is used by academicians for teaching and research; by government research institutions such as Los Alamos National Lab in the US or CINECA in Italy; and by many commercial firms who use VTK to build or extend products. VTK has grown to a world-wide user base in the commercial, academic and research communities since its initial release in 1994.

• The source code is found in the directories Common, Rendering, Filtering, Graphics, Imaging, Hybrid, Parallel and Patented.
  • Common - Core classes
  • Rendering - Classes used to render
  • Filtering - Abstract super-classes for filtering data
  • Graphics - Filters that process 3D data
  • Imaging - Specialized image processing filters
  • IO - Classes for reading and writing data
  • Hybrid - Complex classes that depend on imaging and graphics
  • Parallel - Parallel processing support such as MPI
  • Patented - Patented classes, to be used in commercial applications only with a license

• Examples that are reasonably well documented are found in the Examples/ directory. You may wish to start with the examples found in the Tutorial/ directory.

• The Utilities directory includes things like jpeg, png, and zlib source code. This code is used by VTK in various ways (reading/writing data, etc.)

• The Wrapping directory contains code related to VTK's automated wrapping process. The wrapping process automatically generates Tcl, Python, and/or Java bindings depending on how the build process is configured.

The following instructions only apply to UNIX systems. First we will give you the quick and dirty way to build VTK. Begin by telling CMake what C and C++ compilers you will be using. This can avoid many build problems. On most systems you can pass this information to CMake in the following way:

  env CXX=/your/C++/compiler CC=/your/c/compiler cmake

If you will be using C++ as your development language (no Tcl/Tk, Python or Java support):

  1) untar the src files into directory vtk-src-unix
  2) untar the data files into directory VTKData
  3) cd vtk-src-unix
  4) cmake -i (run cmake in wizard mode, where you have to answer questions about the build)
     or
     ccmake (run the terminal based interface to cmake where you interactively change build options)
  5) change build options if necessary
  6) make

  ls /home/foo
    vtk-src-unix VTKData vtk-solaris
  cd vtk-solaris

  ccmake /home/foo/vtk-src-unix
  or
  cmake -i /home/foo/vtk-src-unix

Note: For your convenience, we have installed VTK on the Unix system in CIS environment. The root directory is /usr/class/graphics/VTK-4.2. The source code and the compilation files (i.e., object code, libraries and executables) are in /usr/class/graphics/VTK-4.2/vtk-src-unix and /usr/class/graphics/VTK-4.2/vtk-solaris respectively. Please note that we assume you will be using C++ as your development language so we only build VTK source code under C++ compiler. If you wanna to use the header files and libraries in VTK, they are located at /usr/class/graphics/VTK-4.2/include/vtk and /usr/class/graphics/VTK-4.2/lib/vtk respectively.

The build process for Cygwin is almost exactly the same as the UNIX build process if you will be using C++ as your development language (no Tcl/Tk, Python or Java support):

The PC build process uses the CMake GUI CMakeSetup. Then you use the compiler make utility to compile as follows:

  1) Install the VTK 4.2 distribution by unzipping into the appropriate directory.

  2) Execute CMakeSetup. This will pop-up a little GUI that allows you to tailor the build. It then starts building 
     .dsw and .dsp files for Microsoft, or makefiles for Borland. You'll have to tell CMakeSetup where you've placed 
     your VTK source code, and where to build the object code and dll's (we'll call it "vtkbin").

  3) When CMakeSetup completes, start up msdev and load VTK.dsw. Select ALL_BUILD project, and build it.

• Strange compile errors on Unix. Make sure that you specify the environment variables CXX and CC prior to running CMake. (If you have already run CMake, do a make clean to remove the cached CMake information.)
• Errors on Tcl or Tk include files. Make sure that you edit CMakeCache.txt to point to the correct location.
• Errors on Tcl or Tk libraries. Make sure that you edit CMakeCache.txt to point to the correct location.
• Link errors on Windows platforms. Make sure that the swap space is at least 300 MByte.
• Link error with borland: TCL82.LIB contains invalid OMF record, type 0x21 (possibly COFF). You have to convert Tcl libraires from coff to omf with the Borland utility coff2omf. Once you have created OMF versions, re-run cmake to tell it where the Borland versions of Tcl and Tk are located. Also, make sure that you are using Tcl/Tk 8.3.2.

  1) Create a new directory called VTK/Local.
  2) Create a file called LocalUserOptions.cmake in VTK/. In that file,add the command SUBDIRS(Local).
     This will add the Local directory to the build.
  3) Create the .cxx and .h file for the new class in VTK/Local. Make sure that you use VTK conventions to
     insure that the wrapping occurs correctly. Complex code may break the wrapper parser; use //BTX and //ETX
     around the  code to fix this.
  4) Create a CMakeLists.txt in VTK/Local. You can model it after a CMakeList.txt file found in another 
     directory (like VTK/IO/CMakeLists.txt).
  5) Rerun ccmake (Unix) or CMakeSetup.exe (Windows).
  6) Then make/gmake (Unix) or msdev (Windows).