# Welcome To ParaView

- Copyright Notice
- Introduction
  - The Origins of ParaView
  - Features
- Compiling ParaView
- Execution

Copyright Notice

    Copyright (c) 2000-2001 Kitware Inc. 469 Clifton Corporate Parkway,
    Clifton Park, NY, 12065, USA.
    All rights reserved.

    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions are met:

     * Redistributions of source code must retain the above copyright notice,
       this list of conditions and the following disclaimer.

     * Redistributions in binary form must reproduce the above copyright notice,
       this list of conditions and the following disclaimer in the documentation
       and/or other materials provided with the distribution.

     * Neither the name of Kitware nor the names of any contributors may be used
       to endorse or promote products derived from this software without specific
       prior written permission.

     * Modified source versions must be plainly marked as such, and must not be
       misrepresented as being the original software.

    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
    ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
    DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
    OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

# Introduction

Welcome to ParaView, an application designed with the need to visualize large data sets in mind. The goals of the ParaView project include the following:

- Develop an open-source, multi-platform visualization application.
- Support distributed computation models to process large data sets.
- Create an open, flexible, and intuitive user interface.
- Develop an extensible architecture based on open standards.

ParaView runs on distributed and shared memory parallel as well as single processor systems and has been succesfully tested on Windows, Linux and various Unix workstations and clusters. Under the hood, ParaView uses the Visualization Toolkit as the data processing and rendering engine and has a user interface written using a unique blend of Tcl/Tk and C++.

The Origins of ParaView
ParaView is being developed by Kitware in conjunction with Jim Ahrens of the Advanced Computing Laboratory at Los Alamos National Laboratory. ParaView is funded by the US Department of Energy ASCI Views program as part of a three-year contract awarded to Kitware, Inc. by a consortium of three National Labs - Los Alamos, Sandia, and Livermore. The goal of the project is to develop scalable parallel processing tools with an emphasis on distributed memory implementations. The project includes parallel algorithms, infrastructure, I/O, support, and display devices. One significant feature of the contract is that all software developed is to be delivered open source. Hence ParaView is available as an open-source system.

Features
The following summarizes the important features of ParaView.

Visualization Capabilities:

Handles structured (uniform, non-uniform rectilinear grids as well as curvilinear grids), unstructured, polygonal and image data
All processing operations (filters) produce datasets. This allows the user to either process further or to save as a data file the result of every operation. For example, the user can extract a cut surface, reduce the number of points on this surface by masking and apply glyphs (for example, vector arrows) to the result.
Contours and isosurfaces can be extracted from all data types using scalars or vector components. The results can be colored by any other variable or processed further. When possible, structured data contours/isosurfaces are extracted with fast and efficient algorithms which make use of the special data layout.
Vectors fields can be inspected by applying glyphs (currently arrows -vector arrows-, cones and spheres) to the points in a dataset. The glyphs can be scaled by scalars, vector component or vector magnitude and can be oriented using a vector field.
A sub-region of a dataset can be extracted by cutting or clipping with an arbitrary plane (all data types), specifying a threshold criteria to exclude cells (all data types) and/or specifying a VOI (volume of interest - structured data types only)
Streamlines can be generated using constant step or adaptive integrators. The results can be displayed as points, lines, tubes, ribbons etc. and can be processed by a multitude of filters.
The points in a dataset can be warped (displaced) with scalars (given a user defined displacement vector) or with vectors (unavailable for rectilinear grids).
With the array calculator, new variables can be computed using existing point or cell field arrays. A multitude of scalar and vector operations are supported.
Data can be probed on a point or along a line. The results are displayed either graphically or as text and can be exported for further analysis.
ParaView provides many other data sources and filters by default (edge extraction, surface extraction, reflection, decimation, extrusion, smoothing...) and any VTK filter can be added by providing a simple XML description (VTK provides hundreds of sources and filters, see VTK documentation for a complete list).

Input/output and File Formats:

Supports a variety of file formats including: VTK (new and legacy, all types including parallel, ascii and binary, can read and written) EnSight 6 and EnSight Gold (all types including parallel, ascii and binary; multiple parts are supported -each part is loaded separately and can be processed individually) (read only) Plot3D (ascii and binary, C or Fortran; support for multiple blocks, I blanking is currently partially supported) (read only) Various polygonal file formats including STL and BYU (by default, read only, other VTK writers can be added by writing XML description)
Many other file formats are supported. See the documentation for details.
Since ParaView is open source, the user can easily provide her own readers and writers.

User Interaction:

Intuitive and flexible interface based on the Tcl/Tk toolkit.
Compact user interface design. All tools are located in the main window. This eliminates the need for large number of windows which are often difficult to locate on a cluttered desktop.
Allows changing the parameters of many filters by directly interacting with the 3D view using 3D widgets (manipulators). For example, the user can manipulate the seed line of a streamtrace filter by clicking on a control point and dragging the line to the new location.
Maintains interactive frame rates even when working with large data through the use of level-of-detail (LOD) models. The user determines the threshold (number of points) beyond which a reduced version of the model is displayed during interaction (the size of the model can also be adjusted). Once the interaction is over, the large model is rendered.

Large Data and Distributed computing:

Runs parallel on distributed and shared memory systems using MPI. These include workstation clusters, visualization systems, large servers, supercomputers etc.
The user interface can be run either on the root MPI node or on a separate workstation using the client/server mode.
ParaView uses the data parallel model in which the data is broken into pieces to be processed by different processes. Most of the visualization algorithms function without any change when running in parallel. ParaView also supports ghost levels used to produce piece invariant results. Ghost levels are points/cells shared between processes and are used by algorithms which require neighborhood information.
Supports both distributed rendering (where the results are rendered on each node and composited later using the depth buffer), local rendering (where the resulting polygons are collected on one node and rendered locally) and a combination of both (for example, the level-of-detail models can be rendered locally whereas the full model is rendered in a distributed manner). This provides scalable rendering for large data without sacrificing performance when working with smaller data.
ParaView supports tiled displays throught built-in display manager. Support for Sandia's Ice-T library is under development.

Scripting and extensibility:

ParaView is fully scriptable using the simple but powerful Tcl language. Every operation has a corresponding script command. Every command executed during a session can be saved in a trace file which can be re-loaded to reproduce the session. Furthermore, since the session file is simply a Tcl script, it can be edited/modified and loaded to obtain different results.
Additional modules can be added by either writing an XML description of the interface (since the XML interface is still being developed, it is not fully documented and is subject to change) or by writing special C++ sub-classes of the main ParaView module (this is only needed for advanced modules). The XML interface allows users/developers to add their own VTK filters to ParaView without writing any special code and/or re-compiling (ParaView can load shared Tcl wrapper libraries at run time).
Since the user interface is written with Tk, it can be modified and extended at runtime either from the command prompt or by loading a ParaView script. For example, it is possible to write a demonstation script which brings up a message window describing the current operation as well as allowing the user to interrupt the demo.

# Compiling ParaView

We highly recommend that you use the ParaViewComplete distribution. If you download a paraview source tarball or checkout the ParaViewComplete module from CVS, you do not need to get VTK or Tcl/Tk separately. This makes the build significantly simpler. See the instructions at the top level of the ParaViewComplete source tree to build it. If you've chosen to build Tcl/Tk and VTK yourself, continue reading.

Install CMake, VTK and Tcl/Tk
To use ParaView, you will have to download and install VTK and CMake. (VTK serves as the visualization engine; CMake is the build environment.)

CMake can be obtained from http://www.cmake.org. See CMake documentation for installation instructions.

VTK is included with the ParaViewComplete distribution and in the paraview source tarballs. You need to get VTK separately only if you used CVS to checkout the ParaView module. VTK can be obtained downloaded from http://www.vtk.org or can be obtained via CVS using the following procedure.

cvs -d :pserver:anonymous@www.vtk.org:/cvsroot/VTK login
(respond with password vtk)

Follow this command by checking out the source code:
cvs -d :pserver:anonymous@www.vtk.org:/cvsroot/VTK co -r ParaView-1-0 VTK

(Note: CVS is a source code revision control system used by many participants in the open-source community. To use CVS, you must have it installed on your system. You may wish to use the Cygwin tools on Windows platforms, or WinCVS which provides a very nice GUI to CVS.

Install and build ParaView differently depending on the operating system. Either way, you must build and/or install CMake, VTK, and Tcl/Tk 8.3.2 prior to compiling and installing ParaView. Please note that ParaView requires Tcl/Tk 8.3.2. It will not work with any other version.

Run CMake and Compile
Once CMake and Tcl/Tk 8.3.2 are installed, you are ready to build VTK and ParaView. We highly recommend reading the CMake documentation if you are not familiar with CMake: http://www.cmake.org/HTML/Documentation.html. (You can skip the Developer's Guide if you are not going to work with CMakeLists files.)

Detailed instructions for configuring and compiling VTK can be found in VTK/README.html. In summary, the VTK (and ParaView) build consists of:

1. Running one of the CMake user interfaces
2. Changing configuration options
3. Compiling (make on Unix, Visual Studio on Windows)

On Windows, you should use the CMakeSetup.exe application to setup the VTK and ParaView build. On Unix/Linux, you should use the CMake wizard (cmake -i) or the terminal interface (ccmake). See the CMake documentation and VTK/README.html for details.

The following build options are the most important ones when building VTK for ParaView. These are taken from real VTK configurations (from both a Linux, gcc and a Windows, Visual C++ build, the values found by CMake are shown inside square brackets). A brief description of each entry is given here to help users configure and build VTK with the right settings. When a value in the following list is optional, it is cleared described as such. Otherwise, the entry must be set to a proper value. Note that some entries are marked (Unix/Linux only) or (Windows only) and are only relevant to the given operating system(s). Usually, CMake will automatically set all of the other build options to appropriate values. However, if a package which is needed by VTK is in an unusual place or if it encounters something unexpected, CMake might not be able to set an option/setting correctly and you might get errors when compiling VTK. If you are not sure about what the problem might be, you can contact the ParaView mailing list.

    BUILD_SHARED_LIBS [OFF]

If you are going to run ParaView in a distributed environment with MPI, we recommend keeping BUILD_SHARED_LIBS OFF. This way, your ParaView executable will not depend on many VTK and ParaView shared libraries and you will have to distribute fewer shared libraries over the nodes of your distributed environment. Other shared libraries (for example, tcl and tk libraries are usually shared) which ParaView is linked against will have to exist (and in the path) on all nodes so that ParaView can find them when running.

    (Unix/Linux only)
    OPENGL_INCLUDE_PATH [/usr/include]

    OPENGL_LIBRARY [/usr/lib/libGL.so]

VTK requires OpenGL. On Windows, this library is almost always found automatically by CMake. On Unix/Linux, you might need to set these values if CMake does not find them when first run. Mesa include files and library can be used instead of OpenGL ones without having to set any other options.

    TCL_INCLUDE_PATH [/usr/local/include]

    TCL_LIBRARY [/usr/local/lib/libtcl8.2.so]

    TK_INCLUDE_PATH [/usr/local/include]

    TK_LIBRARY [/usr/local/lib/libtk8.2.so]

    VTK_WRAP_TCL [ON]

ParaView requires that VTK is built with Tcl/Tk bindings (VTK_WRAP_TCL has to be on). Furthermore, it requires that Tcl/Tk 8.3.2 is used. Any other version of Tcl/Tk will not work. The cache values for the Tcl/Tk include paths and libraries have to be set appropriately. On Windows, we recommend that you install Tcl/Tk 8.3.2 binaries using the default path (C:/Program Files/Tcl/lib). In this case, CMake will automatically find all the necessary paths.

    VTK_USE_HYBRID [ON]

    VTK_USE_PARALLEL [ON]

    VTK_USE_RENDERING [ON]

These modules are required by ParaView and should be turned on.

    VTK_USE_PATENTED [ON]

The patented module is optional. Patented classes may require a license for commercial use. Check the individual header files for patent information.

    VTK_USE_MPI [OFF]

    MPI_INCLUDE_PATH [/usr/local/mpi/include]

    MPI_LIBRARY [/usr/local/mpi/lib/libmpich.a]

MPI is supported by VTK and ParaView but is optional. If this option is on, you will have to specify the MPI include path and the MPI library. Once VTK is built, compiling ParaView is simple. Run CMake as described before for VTK but using the ParaView source and binary directories and set the following value:

    VTK_BINARY_PATH [NOTFOUND]

This entry should point to the VTK binary (build directory). This is where VTK's CMakeCache.txt and vtkConfigure.h are. Once this entry is set, CMake will read VTK's cache file for all the necessary information. You do not have to set any other options. Next build ParaView like you built VTK.

# Execution

For information about how to start and use ParaView, see the online documentation.