Split Python module initialization function out

The module initialization function has always been put into the Python
module itself which is marked as a MODULE in add_library in the VTK
wrapping macros. CMake disallows linking directly to a MODULE, so if
something external to the bindings want to use the module initialization
function, they don't have access to it.

To fix this, the module method is placed in an OBJECT library which can
be linked against to get access to the init function. In addition, the
code which loads each class into the module is moved into the PythonD
library. The Python module itself doesn't use the object library since some
generators do not support targets with only objects from other targets.

This is mainly intended for use in ParaView so that the Python bindings
for classes may be used to implement the ClientServer wrappings with the
Python wrappings instead of generating a second set of bindings.

Change-Id: I8dd2eb672a3b038dedafa79cae271b88fad06082
Properly hide the subclass from the wrapping code

Other code as tried to follow the pattern used in VTK for masquerading
one class as the superclass instead of another for wrapping purposes.
Unfortunately, the way VTK does it isn't a good example since
vtkDataArray is actually a special case in the parser VTK uses for
generating the bindings. Using the __WRAP__ symbol the wrapping code
defines is a better way of handing this.

The wrapping grammar is also updated to not tokenize vtkDataArray.

Change-Id: I9dd9b2d8d3b98c70e3c1542608690ead46355203
Set flags in Python for static and bound methods

Given the following Python class:

    class Example(object):
        @staticmethod
        def static():
            pass
        def method(self):
            pass

the following is true:

    >>> type(Example.static)
    <type 'function'>
    >>> type(Example.method)
    <type 'instancemethod'>

However, in CPython, all methods implemented in C and bound to a type in
C code, print the following:

    >>> type(some.c.class.static)
    <type 'builtin_function_or_method'>
    >>> type(some.c.class.method)
    <type 'builtin_function_or_method'>

so it isn't possible to tell whether a PyCFunction is a static method or
not without actually being in C code. This is done by setting the METH_STATIC
flag on static methods.

Also, using METH_VARARGS rather than '1' is better anyways.

Change-Id: Iab61d26af36c0a6b7a2360dc41c58efaf5dd40b1
Surface LIC : parallelization & fine tuning features

* Parallelization:
Support for Multiblock datasets and MPI parallel usage. Three compositing
strategies are provided, with a heuristic to automatically make a reasonable
selection between them. [1] INPLACE, [2] INPLACE_DISJOINT, [3] BALANCED.
The inplace strategy processes data where it falls given its parallel domain
decomposition and projection to the screen. For simple surfaces such as
slices where ranks/blocks data does not overlap in screen space this is the
most efficient approach. However where ranks/blocks data have large amount
of screen space overlap, this approach has high communication/compositing
and overhead and a large amount of redundant computation that's discarded.
The inplace-disjoint strategy was designed to address these issues. It
leaves data inplace as much as possible but will assign pixels to ranks
uniquely eliminating redundant computation. The communication costs are
the same as the inplace strategy however they are split into two temporally
disjoint parts with computation in between which tends to reduce congestion
and contention. The balanced strategy divides the screen into equally sized
disjoint regions and assigns each rank a region. This strategy can suffer
from load balancing issues, and because no account is made of the initial
data distribution it may have higher communication/compositing costs than
the others. The parallel implementations have been tested with IceT in
ParaView. The compositors uses non-blocking mpi communications, MPI
subarrays for describing non-contoguous memory extents, and communicates
efficiently by pasing mpi gpu mapped memory via extensions made to
vtkPixelBufferObject. An object factory is used to override the serial
objects with their parallel counterparts  when the parallel module is
linked.

* Contrast and Color Contrast Enhancement:
The new contrast enhancement feature increases both dynamic range contrast
while preserving patterns in the LIC. Contrast enhancment is implemented using
histogram stretching. The color contrast enhancement is made in HSL space on
the L channel to minimize color distortions. During the "enhanced" LIC mode
contrast enhancement is also applied after the first pass of LIC compution.
This helps strengthen streaking patterns.

* Enhanced scalar color shading:
A new mode has been added to the shader that shades surface geometry combining
both LIC and scalar colors. The new shader produces bright colors without
diminishing the visibility of the LIC by multiplying colored lit surface with
computed LIC texture. The original blending implementation is left in place
as it works well in many situations.

* Noise texture customization:
A new noise texture generator has been added to improve control over "streaking"
in the convolved texture. The noise textures produced are fully customizable over
9 degrees of freedom. [1] Noise distribution (Gaussian, Uniform, Perlin); [2] Noise
texture size [3] Noise grain size [4,5] Min/max noise values [6] Number of noise
levels; [7] Impulse noise probability; [8] Impulse noise background color; [9]
Noise generator seed

* Fragment masking controls:
The new fragment masking provides controls over the color and intensity of masked
fragments and their blending with scalars. Fragments are masked by threshold |V|<t,
where t is a user specified threshold value, and V are mask vectors. Masking vectors
can be optionally projected onto the surface or passed through un-modified so that
threshold is provided in the original vector units and matches scalar color shading.

* Vector Normalization Control:
The new vector normalization control lets the user turn on and off normalization
in the integrator. Disabling normalization can help highlight relative strengths
in strongly varying regions of a flow field by making the amount of smoothing that
occurs during convolution proportional to the flow strength.

* Antialiasing:
An optional anti-aliasing stage was added. In some cases the CE and EE stages
produce streaks with sharp jagged transitions from black to white. The AA stage
can be used to soften the result and smooth sharp transitions.

* Optimizations:
The implementation has been split into 8 major steps with the result of each stage
cached in a texture.[1] Vector projection and lighting calculation; [2] Gather;
[3] Compositingand guard pixel generation; [4] LIC Computation; [5] Scatter;
[6] Scalar coloring; [7] Color contrast enhance; [8] Depth test. During user
interaction stages that do not have modfied paramters or input data can be skiped
using the cahced result instead.  This can save large amount of time for expensive
operations such as projecting vectors, computing the LIC etc. Classes
were added to simplify monitoring of various system paramters that would trigger
an update, such as changes to lights, modelview or projection matrices, background
color, etc. A new framebuffer object has been introduced, designed specifically
for efficient buffer ping-pong, as well as efficiency improvements for setting
shader unfiorms on inner parts of buffer ping-pong loops.

* Porting and Testing:
The code has been ported to Apple + ATI systems, and to OS Mesa with the gallium
llvmpipe state tracker. A number of ctests have been introduced to excersize the
new features. Parallel features have testing coverage in ParaView.

Change-Id: I26f90a4e1e4e204289d38993d1e32fe5493b7a0d
COMP: Populate VTK wrapping module link interfaces

Since commit 6383648d (COMP: Set CMake Policy CMP0022 to NEW,
2013-09-11) we tell CMake >= 2.8.12 to use the INTERFACE_LINK_LIBRARIES
property to define the link interface of libraries.  Populate it for VTK
wrapping libraries by using target_link_libraries with LINK_PUBLIC.

Change-Id: Id8581ea5039e76eab2c6684bf48e6e6cd80da3b9
COMP: Populate vtkNetCDF_cxx link interface

Since commit 6383648d (COMP: Set CMake Policy CMP0022 to NEW,
2013-09-11) we tell CMake >= 2.8.12 to use the INTERFACE_LINK_LIBRARIES
property to define the link interface of libraries.  Populate it for
vtkNetCDF_cxx libraries by using target_link_libraries with LINK_PUBLIC.

Also fix the vtkIOParallel module implementation to link to
vtkNetCDF_cxx because its sources include netcdf headers.

Change-Id: I2541a05f30311fca4094cfebd2b8fc618fa0eb5e
Merge topic 'cleanup-CMP0022-CMP0023' into master

c118d8bd COMP: Populate vtkNetCDF_cxx link interface
f986259d COMP: Populate VTK wrapping module link interfaces
Merge topic 'remove-cosmo' into pv-master

03ae825 Remove legacy ThirdParty/Cosmo and Filters/Cosmo
23348f0 Merge topic 'module-init-macro' into master
36ee1b7 Added a new macro to initialize a VTK module
2645061 Merge topic 'fix_cosmo_64' into master
1749bb0 Fix 64bit types in cosmo reader.
1a8ba84 Merge topic 'fix-java-package' into master
d1e502e Add CMake options to allow proper Java Packaging of the VTK libraries
e52a8d1 Merge topic 'BadToolTip_PlotPie' into master
e3025f5 BUG: ChartPie tooltip is wrong
fa8f73e Merge topic 'MemoryLeak_TanglegramItem' into master
4eddbb5 Merge topic 'Charts_OverloadVirtual' into master
964a7fa Merge remote-tracking branch 'pvvtk/pv-master' into HEAD
85f895c Merge topic 'add_cosmo_reader' into master
a8660cb COMP: Must delete strings
fd255a8 COMP: Bad signature for GetTooltipLabel
820ceb8 Merge topic 'add-vtk-web-loader' into master
...
Merge topic 'fix_segfault_on_invalid_input' into pv-master

f694dbf BUG #14273: Don't segfault when mapper has empty input.
Merge remote-tracking branch 'pvvtk/pv-master' into HEAD

* pvvtk/pv-master:

Change-Id: If28cd88e33360a620aa3173e5c80bd727492e113
Merge topic 'parallel-surface-lic' into master

ad4dddfc Surface LIC : parallelization & fine tuning features
Merge topic 'unified-bindings' into master

3b3dada2 Set flags in Python for static and bound methods
590e9cf6 Properly hide the subclass from the wrapping code
989050fa Split Python module initialization function out