forked from Kitware/VTK
-
Notifications
You must be signed in to change notification settings - Fork 0
/
README.html
565 lines (505 loc) · 25.4 KB
/
README.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
<HTML>
<header>
<title>VTK README</title>
</header>
<body>
<H1>
<IMG ALIGN="middle" SRC=vtkBanner.gif><br>
Welcome To The Visualization Toolkit
</H1>
<UL>
<LI> <A HREF="#Introduction">Introduction</A>
<LI> <A HREF="#Copyright">Copyright Notice</A>
<LI> <A HREF="#Organization">Organization</A>
<LI> <A HREF="#Documentation">Documentation</A>
<LI> <A HREF="#Compilation">Compilation</A>
<UL>
<LI> <A HREF="#Building">Building with CMake</A>
<LI> <A HREF="#Configuration">Configuration Options in CMake</A>
</UL>
<LI> <A HREF="#Installation">Installation</A>
<LI> <A HREF="#Problems">Common Problems</A>
<LI> <A HREF="#Data">Getting Data</A>
<LI> <A HREF="#Running">Running VTK</A>
<LI> <A HREF="#NewClass">Adding A New Class</A>
<LI> <A HREF="#Help">Getting Help / Mailing List</A>
</UL>
<HR>
<h1><A NAME="Introduction">Introduction</h1>
VTK is an open-source software system for image processing, 3D graphics,
volume rendering and visualization. VTK includes many advanced algorithms
(e.g., surface reconstruction, implicit modelling, decimation) and rendering
techniques (e.g., hardware-accelerated volume rendering, LOD control).<p>
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.<p>
The origin of VTK is with the textbook "The Visualization Toolkit, an
Object-Oriented Approach to 3D Graphics" originally published by
Prentice Hall and now published by Kitware, Inc. (Third Edition
ISBN 1-930934-07-6). VTK has grown (since its initial release in 1994)
to a world-wide user base in the commercial, academic, and research
communities.<p>
This README is written for VTK version 5.0 and greater. For more information,
additional resources, and the FAQ see the web page at
<A HREF="http://www.vtk.org">http://www.vtk.org</A><p>
<HR>
<h1><A NAME="Copyright">Copyright Notice</h1>
VTK has a generous open-source copyright modelled after the BSD license. Yes,
you can use VTK in commercial products. The complete text of the
copyright follows.
<pre>
Copyright (c) 1993-2005 Ken Martin, Will Schroeder, Bill Lorensen
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 name of Ken Martin, Will Schroeder, or Bill Lorensen 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.
</pre>
<HR>
<h1><A NAME="Organization">Organization</h1>
The VTK source code repository is organized into four major sections.
<ul>
<li>The toolkit source code is found in the following directories
next to this README. In some cases an additional README.html
file may be found in the named directory. Please see these for
more information.
<ul>
<li><b>Common</b>- Core classes commonly used by other kits
<li><b>Filtering</b>- Data pipeline implementation superclasses
<li><b>Rendering</b>- Classes used to render a scene (surface primitives)
<li><b>Graphics</b>- Filters that process 3D data
<li><b>Imaging</b>- Specialized image processing filters (2D & 3D)
<li><b>Infovis</b>- Classes for information visualization
<li><b>IO</b>- Classes for reading and writing data
<li><b>Views</b>- Classes for application-level views
<li><b>VolumeRendering</b>- Classes for rendering volume data
<li><b>Hybrid</b>- Complex classes that depend on imaging and graphics
<li><b>Widgets</b>- Classes for interacting with the objects in the scene
<li><b>Parallel</b>- Parallel processing support such as MPI
<li><b>GenericFiltering</b>- Part of an adaptor framework
supporting integration of VTK with external systems
</ul>
</li><p>
<li><B>Examples</B> that are reasonably well documented are found in the
VTK/Examples directory. You may wish to start with the examples
found in the Tutorial directory.<p></li>
<li>The <B>Utilities</B> directory includes things like jpeg, png,
and zlib source code. This code is used by VTK in various ways
(reading/writing data, etc.)<p></li>
<li>The <B>Wrapping</B> 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.<p></li>
</ul>
There are hundreds of testing examples located in the Testing/ directory
under each source code directory (e.g., Graphics/Testing). These are
undocumented tests but can be helpful in some cases.<p>
<HR>
<h1><A NAME="Documentation">Documentation</h1>
The ideal way to learn about the software is from two books:
<i>The Visualization Toolkit, An Object-Oriented Approach to 3D Graphics</i>
and <i>The VTK User's Guide</i> both published by Kitware, Inc. (Note:
<i>The Visualization Toolkit</i> was originally published by Prentice-Hall,
the third edition is published by Kitware.)
You may order the books from the following locations (Amazon.com also
carries the books.)
<pre>
The Visualization Toolkit, An Object-Oriented Approach to 3D Graphics (Third Edition)
by Will Schroeder, Ken Martin and Bill Lorensen.
Kitware, Inc.,
ISBN 1-930934-07-6
<A HREF="http://www.kitware.com/products/vtktextbook.html">http://www.kitware.com/products/vtktextbook.html</A>
The VTK User's Guide (VTK 4.2 Edition)
Kitware, Inc.,
ISBN 1-930934-08-4
<A HREF="http://www.kitware.com/products/vtkguide.html">http://www.kitware.com/products/vtkguide.html</A>
</pre>
On-line Doxygen man pages are also available at
<A href="http://www.vtk.org/doc/nightly/html/">
http://www.vtk.org/doc/nightly/html/</a><p>
<hr>
<h1><a name="Compilation">Compilation</h1>
<div align="left" style="width:720;">
The Visualization Toolkit can be built on UNIX, PC (Windows
95/98/NT/2000/XP), and Mac OSX Jaguar (or greater) systems. VTK uses
<a href="http://www.cmake.org">CMake</a> to generate its build system.
To build VTK one must first install CMake version 2.0 or higher.
CMake may be downloaded from <a
href="http://www.cmake.org/HTML/Download.html">http://www.cmake.org/HTML/Download.html</a>.
The instructions below cover the basics of running CMake for VTK under
the assumption that CMake is already installed. See the CMake web
page for details on
<a href="http://www.cmake.org/HTML/Install.html">intalling</a> and
<a href="http://www.cmake.org/HTML/RunningCMake.html">running</a> CMake.
<p>
Compiling VTK requires a complete VTK source tree. Running VTK tests
requires a complete VTK data tree. Now is the time to extract the
source and data archives if one has not done so already. These
instructions assume there is a directory "<code>VTK</code>" containing
the source code and optionally a sibling directory
"<code>VTKData</code>" containing the data.
<p>
<h2><a name="Building">Building with CMake</h2>
CMake must be run to generate a build system for VTK. The build
system may be placed either in the VTK source tree (an
<i>in-source</i> build) or in a separate binary tree (an
<i>out-of-source</i> build). We strongly encourage use of
out-of-source builds because they make it easy to have multiple builds
with different configurations sharing the same source tree. Once a
single in-source build has been created it is the only build tree that
can be associated with that source tree. A source tree may not be
used both for an in-source build and an out-of-source build, but any
number of out-of-source builds may share a source tree that does not
have an in-source build. Having multiple out-of-source builds is
particularly useful for installing VTK on multiple architectures using
a single source tree on a shared disk.
<p>
CMake provides both a command-line tool and interactive interfaces.
Advanced users may wish to use the command-line tool but here we
document the CMake interactive interface for each platform:
<ul>
<li><b>Windows</b><br>
Run the CMakeSetup dialog to get started. It must be executed
from an environment configured to run the compiler to be used.
In the case of the Visual Studio IDE no special environment is
needed and CMakeSetup can be started from its icon. In the case
of a Visual Studio NMake, Borland C++, or MinGW build the
CMakeSetup dialog should be executed from a command prompt with
the appropriate environment set.
<p>
The dialog prompts for the location of the source and binary
trees. There may also be prompt for the build system generator
to be used ("Build For:"). Once these are set then CMake is
ready for a first pass at configuring the VTK build system. Use
the "Configure" button to initiate this process. If there was
no earlier prompt for the build system generator a separate
dialog will appear during the first configuration step to prompt
for generator selection. After a while the dialog will present
a set of configuration options.
See <a href="#Configuration">below</a> for details on the meaning of
each of these options. After setting the options as desired
press "Configure" again to make another pass at configuring VTK.
New options may appear when earlier options are adjusted. Keep
adjusting options and pressing "Configure" until the desired
configuration is reached. Finally press the "Generate" button
to actually generate the build system.
<p>
Now that the build system has been generated the corresponding
native tools can be used to build VTK. In the case of the
Visual Studio IDE simply run it and load the VTK workspace or
solution file from the binary tree specified in the CMakeSetup
dialog. Select and build the <code>ALL_BUILD</code> target. In
the case of a Visual Studio NMake, Borland C++, or MinGW build
use the corresponding make tool (<code>nmake</code>,
<code>make</code>, and <code>make</code>, respectively) from the
command line.
<li><b>UNIX / Cygwin / Mac OSX</b><br>
CMake should be run from the command line on these platforms.
The current working directory should be set to the desired
binary tree location in which the build system should be
generated. One command-line argument is used to specify the
location of the source tree. CMake will usually choose the
system C and C++ compilers automatically but it can be told to
use specific compilers through the "<code>CC</code>" and
"<code>CXX</code>" environment variables.
<p>
A typical in-source build for VTK might look like this:
<blockquote>
<code>
$ ls -d VTK<br>
VTK/<br>
$ cd VTK<br>
$ ccmake .<br>
$ make<br>
</code>
</blockquote>
A typical out-of-source build for VTK might look like this:
<blockquote>
<code>
$ ls -d VTK<br>
VTK/<br>
$ mkdir VTK-build<br>
$ cd VTK-build<br>
$ ccmake ../VTK<br>
$ make<br>
</code>
</blockquote>
In the above examples the call to <code>ccmake</code> may be
replaced by
<blockquote>
<code>
$ env CC=/your/c/compiler CXX=/your/C++/compiler ccmake /path/to/VTK<br>
</code>
</blockquote>
in order to tell CMake to use specific C and C++ compilers.
Setting the environment in this way will only change the
compilers the <i>first</i> time CMake is run for a specific
build tree. Do not attempt to change the compiler of an
existing build tree. Instead one should create a separate build
tree for each desired compiler.
<p>
The <code>ccmake</code> tool is a curses-based dialog that may
be used to interactively configure VTK. When it appears press
'c' on the keyboard to run the initial configuration of the VTK
build system. Eventually a set of configuration options will
appear. These may be edited using the arrow-keys and the ENTER
key for navigation. See <a href="#Configuration">below</a> for
details on the meaning of each of these options.
<p>
Once the options have been set as desired press 'c' again to
reconfigure. New options may appear when earlier options are
adjusted. Keep adjusting options and pressing 'c' until the
desired configuration is reached. Finally press 'g' to actually
generate the build system. Now that the build system has been
generated just run <code>make</code> or <code>gmake</code> to
build VTK.
<p>
NOTE: The <code>ccmake</code> curses dialog is the most commonly
used interactive interface for CMake on UNIX-like platforms, so
these instructions assume it is available. Some system
administrators may not have installed curses in which case
<code>ccmake</code> will not be available. On these platforms
one may use the command "<code>cmake -i</code>" in place of
<code>ccmake</code> and follow the on-screen instructions to
configure VTK. A last resort is to use the command-line
interface to <code>cmake</code>, but that is beyond the scope of
this document. See CMake documentation for further details.
</ul>
<h2><a name="Configuration">Configuration Options in CMake</h2>
VTK is a large toolkit providing a wide variety of functionality.
Several configuration options are available to customize the VTK build
system. These options are configured through an interactive CMake
interface as described <a href="#Building">above</a>. Note that not
all options are available on all platforms, and some options are
available only when other options are set to a particular value.
<p>
The interactive CMake interface provides brief documentation for every
option. Some options have more meaning than can be described in one
sentence, so additional documentation is provided here:
<p>
<ul>
<li><b>BUILD_SHARED_LIBS</b><br>
<p>
Sets whether the compiled VTK libraries will be shared libraries
or static libraries. When linking executables against static
libraries the needed symbols will be copied from the libraries
into the executables enabling them to run without access to the
original libraries. When linking executables against shared
libraries references to the symbols are placed into the
executables. This has the advantage that many executables can
share a large library without producing many copies of its code.
</p>
<p>
Shared libraries have the disadvantage that they must be found at
runtime in order for an executable to run. Each operating system
supporting shared libraries has a component known as the
<i>dynamic loader</i>. This component is responsible for finding
the shared libraries needed by an executable when it is run. In
order to run VTK executables from the build tree when using shared
libraries one may need to help the dynamic loader find the
libraries (usually the bin subdirectory of the build tree).
</p>
<p>
On Windows, the dynamic loader will look for shared libraries in
the directory containing the executable, in directories listed in
the PATH environment variable, and in some system directories.
Since VTK places all of its executables and libraries in the same
directory nothing needs to be set to get them to run. However,
when one builds outside projects against VTK the PATH environment
variable must be set to point at the directory containing the VTK
shared libraries.
</p>
<p>
On UNIX-style platforms, the dynamic loader will use an
environment variable such as LD_LIBRARY_PATH (Linux and many UNIX
systems) or DYLD_LIBRARY_PATH (Mac OSX) to look for shared
libraries. In order to run VTK executables from the build tree
one must set the appropriate environment variable to point at the
directory containing the VTK shared libraries. The same environment
setting must be used for running outside projects build against the
shared VTK libraries.
</p>
</li>
<li><b>VTK_WRAP_TCL</b><br>
<p>
Enable/Disable automatic generation of VTK bindings in the Tcl
language. In order to build the Tcl-based VTK interpreter one
will need to have Tcl and Tk version 8.2 or newer. Look to
<a href="http://www.tcl.tk">http://www.tcl.tk</a>
for information about getting Tcl and Tk. To turn on Tcl wrapping,
set VTK_WRAP_TCL to ON during the configuration process. One may
then have to set the values for Tcl/Tk include directories and
libraries during the next CMake configure iteration. If there is
more than one version of Tcl installed on the computer, make sure
all the TCL_* and TK_* configuration options are set consistently
to use the proper version. This is especially important when
Cygwin is installed because the Cygwin Tcl will not work for a
native Windows VTK build and a Windows Tcl will not work for a
Cygwin VTK build. When building the Tcl/Tk wrappers on Cygwin one
must also install the Cygwin sources for Tcl/Tk and set
TK_XLIB_PATH to "/usr/src/tcltk-20030901-1/tk/xlib" or the
corresponding directory for one's Cygwin Tcl version. See
<a href="Wrapping/Tcl/README">Wrapping/Tcl/README</a>
for details on using the Tcl wrappers once they are built.
</p>
</li>
<li><b>VTK_WRAP_PYTHON</b><br>
<p>
Enable/Disable automatic generation of VTK bindings in the Python
language. In order to build the Python-based VTK interpreter one
will need to have Python installed. Look to
<a href="http://www.python.org">http://www.python.org</a>
for information about getting Python. To turn on Python wrapping,
set VTK_WRAP_PYTHON and BUILD_SHARED_LIBS to ON during the
configuration process. One may then have to set the values for
Python include directories and libraries during the next CMake
configure iteration. If there is more than one version of Python
installed on the computer, make sure all the PYTHON_*
configuration options are set consistently to use the proper
version. This is especially important when Cygwin is installed
because the Cygwin Python will not work for a native Windows VTK
build and a Windows Python will not work for a Cygwin VTK build.
In order to use Tkinter with VTK-Python make sure that the Tcl/Tk
libraries that are set correspond to the same version used by
Tkinter.
</p>
<p>
Note that the VTK-Python modules are now installed by default via
'make install', which is a change from previous VTK versions. The
automatic python module installation is highly configurable. The
<a href="Wrapping/Python/README.txt">Wrapping/Python/README.txt</a>
file documents the installation procedure and the VTK-Python
modules.
</p>
</li>
<li><b>CMAKE_INSTALL_PREFIX</b><br>
<p>
When VTK is <a href="#Installation">installed</a> all files are
placed in a directory structure rooted at the directory specified
by CMAKE_INSTALL_PREFIX.
</p>
</li>
</ul>
<HR>
<h1><A NAME="Installation">Installation</h1>
Installing VTK from a source distribution requires first that it be
compiled in a build tree. See the <a
href="#Compilation">compilation</a> section above for details. Once
VTK has been compiled in a build tree one may build the <i>install</i>
target to actually put VTK in an installation tree. If VTK was built
using a CMake Makefile generator then this is done by running "make
install" from the top of the build tree. If VTK was built using a
CMake project file generator (such as Visual Studio), then building
the INSTALL project from inside the IDE will install VTK. The
installation process will install all files in a directory structure
rooted at the directory specified by CMAKE_INSTALL_PREFIX.
</div>
<HR>
<h1><A NAME="Problems">Common Problems</h1>
<ul>
<li>Strange compile errors on UNIX, typically involving system
headers and types. Make sure that you specify the environment
variables CC and CXX prior to running CMake. If you have
already run CMake you must create a fresh build-tree and start
again. If you ran CMake in the source tree then you must delete
the source tree, re-extract the sources, and start again.
<li>Errors on Tcl or Tk include files or libraries. Make sure that
you set the TCL_* and TK_* configuration variables to the
correct location when running CMake.
<li>Link errors on Windows platforms. Make sure that the swap space is
at least 300 MByte.
<li>Link error with borland: TCL82.LIB contains invalid OMF record,
type 0x21 (possibly COFF). You have to convert Tcl libraries
from coff to omf with the Borland utilitiy 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.
</ul>
<HR>
<h1><A NAME="Data">Getting Data and Test Images</h1>
Many of the examples require data. There are two ways to get data. The
first is to download the file VTKData.tgz. The second is to access the
data via CVS checkout. The CVS checkout also includes many test images
used by the testing process (see <A href="http://public.kitware.com/dashboard.php">http://public.kitware.com/dashboard.php</A>).
These can be used if you wish to test VTK or submit testing dashboards.
The VTKData.tgz contains only data in compressed form is therefore can
be obtained much faster.
<pre>
1) Download the data at ftp://public.kitware.com/pub/vtk/VTKData.tgz
2) Checkout the data from CVS using the following commands:
cvs -d :pserver:[email protected]:/cvsroot/VTK login
(there is no password...just press enter)
cvs -d :pserver:[email protected]:/cvsroot/VTK checkout VTKData
</pre>
<HR>
<h1><A NAME="Running">Running VTK</h1>
Many C++ examples will be compiled if BUILD_TESTING and/or
BUILD_EXAMPLES are enabled in CMake. To run these C++ examples just
type their name. (They will be found in the binary build directory.)
If you have built shared libraries, make sure the PATH environment
variable (Windows) or the LD_LIBRARY_PATH (Unix) point to the shared
libraries (see above documentation of the BUILD_SHARED_LIBS for
details).
If you have enabled Tcl wrapping, you will want to set TCLLIBPATH to point to
the VTK/Wrapping/Tcl directory and check the instructions located in the <A
href="Wrapping/Tcl/README">Wrapping/Tcl/README</A> file. You will then run
the VTK executable found in the bin directory where the code was
compiled. Assuming that the executable VTK is in your path, or has been
aliased, you would type:
<pre>
vtk mace.tcl
</pre>
Note that most Tcl scripts allow you to type "u" in the render window to
obtain an interpreter. You can use the interpreter to modify the application
at run-time.
<P>
If you have enabled Python Wrapping you should read the instructions
located in the <A
href="Wrapping/Python/README.txt">Wrapping/Python/README.txt</A> file.
</P>
<HR>
<h1><A NAME="NewClass">Writing Your Own Class</h1> There are several ways to
extend VTK. The simplest way is, in your own code, create classes that
inherit from the appropriate VTK classes. Please see the
<a href="Examples/Build/vtkLocal/README"><code>vtkLocal</code></a> example
for instructions to build your classes outside VTK.
<HR>
<h1><A NAME="Help">Getting Help / Mailing List</h1>
For general information go to the VTK web site
<a href="http://www.vtk.org">http://www.vtk.org</a>
<p>
If you run into problems, your best bet is to join the VTK mailing list.
Visit <a href="http://www.vtk.org/mailman/listinfo/vtkusers">
http://www.vtk.org/mailman/listinfo/vtkusers</a> to join the list.
<p>
Commercial support contracts are available from Kitware at
<a href="http://www.kitware.com/products/vtksupport.html">
http://www.kitware.com/products/vtksupport.html</a>.
<p>
Kitware also provides consulting services. Read more at
<a href="http://www.kitware.com/products/consult.html">
http://www.kitware.com/products/consult.html</a>.
<p>
Training is also available from Kitware. See
<a href="http://www.kitware.com/products/vtktrain.html">
http://www.kitware.com/products/vtktrain.html</a>.
</body>
</HTML>