ParaView Release Notes

ParaView 5.5.0 Release Notes

The full list of issues addressed by this release is available here. Major changes made since ParaView 5.4.1 include the following:

Rendering Enhancements

More updates to OSPRay ray traced rendering

ParaView’s Ray Traced Rendering capacity continues to evolve. In this release we’ve updated to a new version of OSPRay that gives us the ability to directly volume render Overlapping AMR and Unstructured Grid data in addition to the Structured Grid that we’ve had for a couple of releases now. We’ve also exposed a path tracing option for surface geometry. What this does is give the capacity for full photorealism by sampling the scene with many more rays and ray bounces than before. For this purpose we’ve added the Light Inspector panel in which you can add, remove and more precisely control an arbitrary number of lights in the scene. The Light Inspector’s radius control, which results in soft shadows with the path tracer, is the only part of the panel that is specific to OSPRay, the rest is also useful for standard rendering. Also, for the purpose of photorealism, we’ve added an ability to import JSON-based OSPRay Material specification files. Materials are a way to give objects, blocks, or cells advanced textures and arbitrary appearance properties that make them look like metal, glass, and other real world effects. Note that many features of the path tracer (like shadows before and reflections and refractions now) will result in rendering artifacts in distributed memory parallel runs.

OSPRay path tracer combined with typical visualization capabilities
OSPRay path tracer combined with typical visualization capabilities.

Support for rendering lines as tubes and points as spheres

Using Render Lines As Tubes and Render Points As Spheres properties in the Display section on the Properties Panel, it’s now possible to render lines as 3D tubes and points as 3D spheres.

Preview mode

To make it easier to generate publication quality images, ParaView has a new Preview mode. Preview mode is similar to the Print Preview mode offered by many tools, including your web browser. The idea is to provide a way to do final visualization setup just prior to saving a screenshot or animation in a way that minimizes surprise object rescaling in the save image output, which can happen if the ParaView window aspect ratio differs from the requested image resolution aspect ratio. To use Preview mode, select a target resolution from the View -> Preview submenu and the active layout will be resized to match the chosen resolution. If the target resolution is larger than the space available for the layout tab on your screen, it will be resized to match the target aspect ratio.

Preview mode resolution size selection
Preview mode resolution size selection.

Improvements to Eye Dome Lighting with remote rendering.

A number of bugfixes went into the Eye Dome Lighting and IceT layers to allow this screen-space ambient occlusion algorithm to work on parallel/remote render servers.

Embossing plugin

This plugin adds three new representations.

• BumpMap : computes on the GPU fake normals based on the gradient of the selected point data, creating a relief effect.
• Extrusion (cell mode) : computes on the GPU an extrusion based on the value of the cell.
• Extrusion (point mode) : computes on the GPU a height field based on the value of the cell.

Extrusion map created with the embossing plugin
Extrusion map created with the embossing plugin. Data and picture credit: http://www.dkrz.de/.

Categorical coloration improvements

• Annotation now always has a color, using a default and by looping when adding annotations after the size of the color map.
• Automatic annotation generation can now be forced over its previous maximum (32).
• The Color Legend is now hidden automatically when the number of annotations is bigger than 32.
• Opacity can now be set globally, on the selected category, or on an individual category.

Depth peeling for volumes

This option is now exposed through settings. Enabling it will include volumes in the depth-peeling pass to render intermixed volumes with translucent polygons correctly.

3D Glyphs representation culling

It is now possible to enable culling and level of detail (LOD) in the 3D Glyphs representation. This enables rendering a higher number of glyphs at interactive frame rates. When the option is enabled, instances that are not visible are discarded and not drawn. One can also specify LOD parameters inside a table. The first table column is the distance after which the LOD is enabled, the second column is the reduction factor applied to the instance geometry. It is also possible to display instances in different colors depending on the LOD. Please note that this feature works only with OpenGL driver >== 4.0.

3D Glyphs representation option in the user interface
3D Glyphs representation option in the user interface.

3D Glyphs rendering 1 million instances of a bunny model
3D Glyphs rendering 1 million instances of a bunny model.

Horizontal color legend title in vertical orientation mode

As in earlier versions of ParaView, it is again possible to orient the color legend title horizontally when the color legend is oriented vertically. By default, the title is rotated 90 degrees counterclockwise and aligned with the color legend vertically.

Image volume representation can now render isocontours

Thanks to a recent change in VTK, it is now possible to use the OpenGL-based volume rendering mapper to display isocontours without precomputing them on the CPU. This feature is exposed through two new properties on the image volume representation: Show IsoSurfaces to enable the feature, and Contour Values to specify the isocontours values similar to how they are set in the Contour filter.

Image volume representation isocontours
Image volume representation isocontours.

New Features

Adding filters from the Pipeline Browser context menu

It is now possible to create new filters from the Pipeline Browser context menu. Only filters that are applicable to the active source are shown in the context menu.

Saved custom camera positions

Adjust Camera dialog now allows saving of more than 4 camera positions. The limit has been extended to 30 positions, with a minimum of 4. You can add/remove positions within this limit using the Adjust Camera dialog’s Configure… button.

Added LZMA compressor and compression level setting for XMLWriter

The LZMA lossless compressor is now available when writing XML data files, offering a higher compression ratio and higher write time compared with existing LZ4 and ZLib compressors. A Compression Level setting is now available to fine tune the tradeoff between compressed file size and write time for each compressor.

Arbitrary-order Lagrange finite element support

ParaView’s XML readers and writers support arbitrary-order Lagrange finite elements. The Unstructured Cell Type source can be used to generate representative grids with Lagrange elements.

Higher-order wedges
An example of a grid with higher-order wedges.

Proxy sources selection order is now respected

Previously, the order of selection of the proxies in the pipeline was not respected. For instance, selecting a Box Source first and then a Sphere Source in the pipeline before applying a Group DataSets filter did not ensure that block 0 would be the box. Selection order is now respected - note that order was already respected when using the Change Inputs dialog.

Introduce a new plugin called DigitalRockPhysics for rock analysis

This plugin introduces two new filters to help the analysis of digital rock.

• The Material Cluster Analysis filter produces a multiblock dataset that contains two blocks:
  • A table (block 2) that contains the volume (number of cells of every cluster) and barycenter of every cluster (set of connected cells that have the same point data material attribute); and,
  • A copy of the input data image (block 1) with new point data arrays that correspond to the volume and barycenter of the material cluster it belongs to.
• The Material Cluster Explode filter creates an exploded surface mesh of the clusters (the set of connected cells that have the same material attribute) described in the input image data.

Exploded rock view from the DigitalRockPhysics plugin
Exploded rock view from the DigitalRockPhysics plugin.

Expose vtkMolecule type for Programmable Source and Programmable Filter

We add support for vtkMolecule as input/output data type in the Python Programmable Source and Programmable Filter. Molecule type is now also exposed correctly in the Information Panel.

AMReX particles reader

ParaView now supports reading particle data from AMReX plotfiles. The reader supports both single plotfile or multiple plotfiles that form a time series.

JSON based new meta file format for series added

vtkFileSeriesReader now supports a new meta file format based on JSON. This format has support for specifying time values. The format (currently version 1.0) looks like the following

<source lang="json">{

 "file-series-version" : "1.0",
 "files" : [
   { "name" : "foo1.vtk", "time" : 0 },
   { "name" : "foo2.vtk", "time" : 5.5 },
   { "name" : "foo3.vtk", "time" : 11.2 }
 ]

}</source> The reader will interpret any files that end with the .series extension as a === meta file. To add support for the meta file for a reader in the readers description, add the extension.series extension to the extension list. For example, for legacy VTK files, the reader now supports .vtk and .vtk.series

GDAL and PDAL Readers

ParaView now supports geospatial (GDAL Raster and Vector Reader) and point cloud data (PDAL Reader). Any dataset supported by GDAL or PDAL libraries is now supported by ParaView.

Orthorectified satellite image and a point cloud of Jacksonville, FL
An orthorectified satellite image and a point cloud of Jacksonville, FL, rendered in ParaView.

CGNS library updated to v3.3.1

CGNS library has been updated to version 3.3.1. This version contains a bug fix that allows loading large files in Windows.

Orienting by quaternion in 3D Glyph representation

When the 3D Glyph representation is selected, one can use a data array to define the orientation of the glyphs. Previously, one had a choice between direction vector or angles around three axes (both by selecting a 3-components array). We added a new Quaternion mode to specify the orientation through a 4-components point array with quaternions defined in WXYZ format.

Plotting full dataset over time

A newly added filter Plot Data Over Time supports plotting entire datasets, and not just the selected subset. When in distributed mode, however, the current implementation show stats for each rank separately. This will be fixed in a future release to correctly compute distributed statistical summaries.

Selecting arrays to read in PVD reader

PVD reader (vtkPVDReader) now supports selecting which arrays to read. This can be useful to minimize memory foot print and reduce I/O times when reading PVD files by skipping arrays that may not be needed.

Restore user preferences to default

ParaView now supports restoring user preferences to default from the Edit menu. One can optionally generate backup files before restoring user preferences to default.

Format-specific options in save animation and screenshot dialogs

Dialogs for save-screenshot and save-animation now show file format-specific options for quality, compression, etc., rather than a single Image Quality parameter which was internally interpreted differently for each file format. This allows the user finer controls based on the file format, in addition to avoiding confusion.

Support of TrueType font files

It is now possible to display 2D and 3D text with TrueType font files you provide, and thus use fonts different from the built-in fonts (Arial, Courier, and Times). This feature is accessible by choosing File as the font family in the Font Properties property and then specifying the full path to the .ttf file in the file selection field.

TrueType fonts can now be used for text.
TrueType fonts can now be used for text.

Upgrade from vtkHyperOctree to vtkHyperTreeGrid

All functionality related to the experimental vtkHyperOctree tree-based AMR implementation has been deprecated in VTK and removed from ParaView. It is being replaced with the newer vtkHyperTreeGrid data structure, which is more efficient and more expressive than its predecessor. The new vtkHyperTreeGrid is a superset of previous implementation. This ParaView release includes a more efficient hyper tree grid implementation than in 5.4 along with VTK XML based IO, a few dedicated filters, and bug fixes.

Clip filter improvements

Clip filter now can clip away the exact exterior of a box. Note, though, that this is an expensive operation as it performs six plane clips in order to provide the exact box clip.

Which portion of the geometry was clipped has been inverted as the default was confusing for the Box, Sphere, and Cylinder. Now, the clipped geometry is interior to the clip shape rather than exterior.

Ghost cell utilities

The Generate Ghosts Cells filter was added. It generates a requested level of ghost cells. The Remove Ghost Information filter will remove ghost cells from datasets.

Filter changes

Attribute arrays appended with the Append Attributes filter are renamed to accommodate inputs with arrays having the same name.

All filters are now available in the GUI regardless of how many pvserver processes are being used. This will allow filters like Process Id Scalars and Generate Ghosts Cells to be easily added with a serial pvserver process with the intent of saving a Python trace, state, or generating a Catalyst Python script that can be properly used in parallel later on.

Added option to specify array type for Calculator filter. This is the available via the new Result Array Type advanced option.

Added the Cell Size filter to measure the number of points for vertex or polyvertex cells, length for 1D cells, area for 2D cells and/or volume for 3D cells.The sizes are output in separate cell data arrays and you can choose which arrays to output. The filter also includes an option to sum the size and will output this in field data arrays.

Added new options for vtkGradientFilter for controlling which cells contribute to the gradient calculation.

Reader and writer changes

A new GenericIO reader provides support for reading Argonnes National Laboratory’s GenericIO files produced by the HACC simulation code. It also allows sampling of the GenericIO files as well as basic filtering operations.

Improved the file series writer to allow specifying min, max and stride for time steps.

Added the ability to read raw images as a time series.

Added option to write out all time steps for XML PVD Writer (i.e. .pvd output files).

Added option to output text files as tab-delimited. The file extension for this is .tsv.

Catalyst

Created a Catalyst volume rendering edition.

We added a volume rendering edition for Catalyst.

ParaViewWeb

Several improvements have been made in VTK/ParaView Web to offer better image delivery performances. We added new controls for the server side to manage image resolution and framerate while interacting.

The Web applications have also been updated accordingly to leverage those new capabilities.

ParaView 5.5 bundles the following applications:

• ParaView Visualizer 3.1.0
• ParaView Divvy 1.3.14

Build and Installation Notes

Installation tree cleanup

On Unix, ParaView no longer installs its libraries under <prefix>/lib/paraview-${paraview-version}. Instead, it follows the standard practice of installing them under <prefix>/lib directly.

Python packages built by ParaView are now built and installed under <prefix>/lib/python-$<python-version>/site-packages on *nixes, and <prefix>/bin/Lib/site-packages on Windows. This is consistent with how Python installs its packages on the two platforms. In macOS app bundle, the location in unchanged i.e. <app>/Contents/Python.

Plugins build and installation tree cleanup

Plugins are built and installed in self contained directories named same as the plugin under PARAVIEW_BUILD_PLUGINS_DIR and PARAVIEW_INSTALL_PLUGINS_DIR. These are set to lib/paraview-${paraview-version}/plugins (bin/plugins on Windows) by default. For macOS app bundles too, while the plugins are installed under <app>/Contents/Plugins, they are now contained in a separate directory per plugin.

The .plugins file has also been moved to PARAVIEW_BUILD_PLUGINS_DIR and PARAVIEW_INSTALL_PLUGINS_DIR for builds and installs respectively.

Developer Notes

Easier array selection properties

vtkSIDataArraySelectionProperty makes it easier to expose array selection properties for filter/readers that support an API to toggle selection status using vtkDataArraySelection instance. See vtkSIDataArraySelectionProperty docs for details.

Promote coprocessing plugin’s writers and generator to Catalyst menu

We removed the CoProcessingScriptGenerator plugin and promoted its functions to mainline ParaView. As before they depend on Python and Qt, but otherwise they are now always available. With this we removed the plugin’s two menus and moved their contents under the Catalyst menu.

Client server wrapping property

The ClientServer wrapping tool now uses the WRAP_EXCLUDE_PYTHON property rather than WRAP_EXCLUDE. It also now properly skips classes which cannot be wrapped with no-op wrappings (rather than failing as before). One limitation currently is that files with no classes still need to be excluded since the wrapper does not know what name to use when creating the no-op function.

info attribute for EnumerationDomain

EnumerationDomain now supports info attribute for each of the entries. If present, the UI will show that text in the combo-box rendered for the domain to provide you additional tips for the items to choose.

Adding QToolBar via plugins

ParaView now supports add a QToolBar subclass via the plugin mechanism. In the past, one had to add actions to a toolbar via a QActionGroup. Now, directly adding a QToolBar is a supported by using add_paraview_toolbar CMake function.

New proxy hint WarnOnCreate

Sources and filters XML now supports an ability to add a warning or information message for the user to be shown when creating the source or filter. See WarnOnCreate hint for details.

ParaView 5.4.1 Release Notes

This bug fix release addresses a number of problems in 5.4.0, including:

• The black render window observed on some systems when FXAA was enabled or an object’s opacity was less than 1 has been fixed.
• Field output for cells with non-straight edges has been corrected.
• Derivatives for quadratic triangles are now computed correctly.
• A bug that occurred when generating a Catalyst script with no images output has been fixed.
• A problem with writing animations as AVIs was fixed.
• Logic in the CGNS reader was updated to correctly read all solution nodes for each centering type when FlowSolutionPointers are missing.
• Fixed crash in CGNS reader when moving forward in time.
• Fixed problem with long-running animations not advancing past a certain number of time steps.
• Resolved issue where changing one file path in the state file loader “Choose File Names” dialog also changed the file paths of other files with the same type.
• Addressed problem with enumerated property dependencies in ParaViewWeb.
• Added ability to change the font size in the ParaView user interface.
• Fixed BoxLib3D file reader.
• State files now properly support files with relative paths.
• Removed inappropriate scalar bar scaling when saving large screen shots.
• A bug in the color mapping that in some cases incorrectly mapped some data values to the above-range color was fixed.
• OSPRay can now be compiled in Cray programming environments and for the first time has support for Intel Skylake processors.
• Added lower limit to how small the GUI font size can be.
• Addressed issue affecting layouts when loading a state file from the Python console.

ParaView 5.4.0 Release Notes

New Color Legend

A new color legend fixes numerous bugs in the previous version and includes additional advances:

• Nicer automatic labels at nice values that require fewer digits to represent
• Support for specifying arbitrary labeled values
• Display of out-of-range colors
• Improved annotation layout
• More precise font control
• Simpler control of the color bar thickness
• Options for locking the color legend to different within the render view

VTK-m Filter Enhancements and Additions

The VTKm Contour filter now supports more than one isocontour value. Additionally, new VTK-m-accelerated filters have been added that:

• Average the values of the point attributes at the points defining a cell to compute cell attributes (VTKm Point Data to Cell Data)
• Average the values of the cell attributes of the cells surrounding a point to compute point attributes (VTKm Cell Data to Point Data)
• Clean unstructured grids (VTKm Clean Unstructured Grid)
• Clip data sets by a scalar value (VTKm Clip)
• Extract the external faces from datasets (VTKm External Faces)

New Options when Loading State Files

ParaView provides new options for locating data files referenced by state files. One can use the file names stored in the state file, specify that all files are located in a particular directory (default is the same directory as the state file), or choose to select each data file separately. These options are meant to make it easier to share state files with other ParaView users.

Multiblock Inspector Enhancements

The Multiblock Inspector panel used to inspect and change display properties for multiblock datasets underwent several usability improvements. Helpful legend and tooltips together with clearer icons should make it easier to work with complex data hierarchies.

Output Messages

The Output Messages window is now dockable and is accessible from the View menu (instead of Tools). This widget was tweaked for improved usability, including clearer grouping indication, and better icons.

Data Axes Grid

We brought back the ability to render a grid around individual datasets, and not just the entire scene. Users can turn on Data Axes Grid from the Properties Panel to show this grid for a specific dataset.

Saving Animations and Screenshots

Dialogs for saving screenshots and animations have been redesigned to allow you to modify all relevant options from a single place, including saving images with transparent background. The Python API for the same has also been revamped to provide access all available options.

Improved Selection Link

A new option called Link by selected Elements has been added to the Selection Link feature. When enabled (the default state), the two sources/output ports that are linked together will share the ids of the selected elements and not directly the selection object. This is useful for instance if you want to select some elements (points or cells) on a first source via a frustum-based selection and link the selected elements with a second source. In this case the elements selected on the first source (obtained after conversion of the frustum-based selection to an id-based selection) will automatically be selected on the second source.

Better Support for Large Files

Thanks to the newly introduced vtkSystemTools::Stat() method, ParaView can now open files larger than 4 GB on Windows with most of the readers. Some readers, especially for the legacy VTK file format reader, were not able to do this before.

Improved Performance when Navigating Large Directories

By using vtkSystemTools::Stat() only when extra information about the file, such as file size and modified time, is explicitly requested, ParaView avoids the performance penalty of stat-ing thousands of large files in large data directories when just the filenames are requested.

Temporal Array Operator

A new filter called Temporal Array Operator allows application of simple operators between array values at two different timesteps. For instance it allows to compute the difference array of a temperature array between step 54 and step 0.

New support for HiDPI displays

ParaView now takes full advantage of HiDPI displays such as Apple’s Retina displays for greater rendering detail and sharper text.

Reminder to Save State

When enabled, a new option in ParaView’s General settings tab will prompt you to optionally save a state file before exiting ParaView.

Virtual Reality Support

ParaView can now be built with OpenVR support. Visualizations set up with ParaView can be sent to headset devices supported by OpenVR for rendering.

Array Ranges Computed from Finite Values

Now data array ranges used for color mapping are computed over only finite values to better support datasets where infinite values are present and have a special meaning.

Hover Cells On Selection Mode

ParaView now has a Hover Cells On selection mode that shows cell information in a tooltip as each cell is moused over. This is similar to the existing Hover Points On mode available in previous versions.

Known Issues

• When creating a source and showing it in the Python console or via Python script, but not rendering it in the same script and then interacting with the render view, a number of error message about invalid arguments will be generated. When the first interaction stops, this messages will no longer be generated. #17492

ParaView 5.3 (Mar 2017)

VTK-m Plugin

This release introduces the VTKmFilters plugin that includes an initial collection of VTK-m filters that fully utilize many-core architectures. This new plug-in comes with support for many-core systems via Threading Building Blocks (TBB). If desired, you can enable GPU support via CUDA by building ParaView from source with a VTK-m that has CUDA support enabled.

This initial release offers the following filters: Threshold, Contour (single-valued contours), Gradient (including divergence, vorticity, and q-criterion computation), and Level of Detail.

All of these filters excluding Level Of Detail support Unstructured Grids, Rectilinear Grids, Image Data, Uniform Data, and Poly Data of a single cell type. The Level Of Detail filter currently supports only Unstructured Grids and Poly Data of triangles. With the introduction of VTK-m, we have removed the earlier Piston and Dax GPU filtering options.

• Reader and Writer Improvements and Additions

• Added support for accented and special characters in file paths.

• Updates to the OpenFOAM reader include full support of 32-bit and 64-bit binary formats, better coverage of the Lagrangian formats, and the option to skip the initial conditions directory. The changes are a cooperative effort of Kitware, Inc., and ESI-OpenCFD Ltd (www.openfoam.com).

• Added a new reader for Truchas metal casting and processing simulation data files.

• Improved support for temporal CGNS datasets, including those with missing or incorrect ZoneIterativeData_t. In such cases, the flow solution node name is used to deduce which timestep the node corresponds to.

• Numerous fixes and improvements to Cinema export, the most important of which were

• Fixes for cell aligned and multiblock data

• Depth and value rasters are now output as zlib-compressed raw files for wider compatibility

• Besides exporting Cinema databases, ParaView now also supports importing Cinema databases for viewing. This is first version of this functionality, currently only supported in builtin mode, and is expected to improve in future releases. By importing Cinema databases, one can not only view the visualizations in the database, but also combine the same with other geometry and datasets in the same view.

Rendering Improvements

• Fast approximate anti-aliasing (FXAA) is now on by default. It can be disabled through Setting/Preferences through the “Use FXAA” setting in the “Render View” tab. This release also addresses issues when using FXAA together with SurfaceLIC.

• EyeDomeLighting plugin is now supported with OpenGL2 rendering backend. The plugin had been disabled since 5.0.

• OSPRay integration continues to mature. In this version we have bumped to OSPRay version 1.1.2 to catch a couple of bug fixes and added support for progressive refinement. To try it start ParaView with –enable-streaming and enter the maximum number of refinement passes for still renders in the “Progressive Passes” control in the OSPRay View properties section.

• Added an option to show Polar Axes on a representation.

• New Features

• Introduced a new StreamLinesRepresentation plugin to display animated streamlines. It adds a “Stream Lines” option to the representation list.

• Added LagrangianParticleTracker plugin that adds the “Lagrangian Particle Tracker” filter.

• Added “Append Reduce” filter that can move data among MPI processes on the server.

• Added a –servers-file=<file> command-line option to specify a custom *.pvsc file that contains remote ParaView server connection information. When specified, this file is used instead of the default *.pvsc file.

Python Enhancements

• Python 3 support has been improved and is now officially supported, with the exception of ParaViewWeb components.

• Added a Python function paraview.simple.ResetProperty to reset a property to its default

Miscellaneous Improvements

• Properties for only the currently selected representation are now shown to avoid cluttering the user interface.

• Fixed bug with SurfaceLIC representations, performance should be significantly better and you should not see hangs in MPI runs now.

• Removed limit of 4096 time steps in annotated .vtu files.

• Added a mouse wheel zoom factor in Settings/Preferences to control the speed of zooming when the mouse wheel is moved.

Known Issues

• Several problems have been identified with the Point Gaussian representation

• A fair number of issues remain to bring OSPRay based rendering into close compliance with OpenGL based rendering. For example, Points (like those shown in the figure above) and Lines show a solid color instead of color mapped colors unless “Interpolate Scalars Before Mapping” is turned off. Another distracting mismatch is that volume rendering for unstructured data silently produces blank results. Here the “Resample To Image” filter is a viable workaround. You can find the list of items we aim to improve over the next several ParaView releases with the “area:ospray” label on the VTK and ParaView issue trackers.

• See the full list of open ParaView issues.

Special Note for Dell Backup and Recovery Users

Users of “Dell Backup and Recovery” software may see ParaView crash on startup. This is a known issue for applications like ParaView that are built with Qt 5. To resolve the issue, either update or remove the “Dell Backup and Recovery” software.

Developer Notes

• Integration of new QtTesting features, Continuous Flush, and Interaction Timings recording

• Introduced SharedProperty hints for ProxyListDomain

• Corrected ColorBy and adding RemoveLayout Python trace functions

• Adding a disable_sub_trace ivar on ProxyProperty so it is not Python traced

• ParaView GUI now uses Qt 5. Qt 5 is the latest version of Qt that enables cross platform development of applications with intuitive user interfaces. Switching to Qt 5 allows us to better support newer operating systems such as Windows 10 and macOS, including supporting HDPi displays.

• ParaView example applications have been updated

ParaView 5.2 (Nov 2016)

New Rendering Features

• Anti-aliasing is now available in ParaView. It can be enabled by checking “Use FXAA” in the Render View section of ParaView’s general settings.

• Hidden line removal is available for rendering only the nearest portions of a wireframe model.

• Molecule rendering saw numerous improvements, including color legend support, custom atomic radii, and the ability to color atoms by arbitrary scalar arrays.

• ParaView’s Intel OSPRay-based ray traced rendering backend, which was introduced in 5.1, continues to mature. In 5.2 we fixed a number of reported bugs, updated from OSPRay version 0.10.0 to 1.1, and gained full access to OSPRay’s volume rendering. The performance falls between VTK’s own fixed point CPU and GPU enabled volume renderers. Of particular interest is that this is VTK’s first volume rendering option that enables volumes to cast shadows, albeit only in non-distributed memory cases.

• Improvements to VTK’s GPU volume mapper prevent seam artifacts due to discontinuous sampling when doing parallel volume rendering.

• Volume rendering by vector components and vector magnitude is now available for structured data when using the GPU-based volume rendering mode. There is no longer a need to use an intermediate Calculator filter to compute these quantities. This mode makes use of the GPU-based volume rendering’s independent component support and computes a magnitude array automatically behind the scenes.

• Mixed multiblock and composite dataset rendering with the OpenGL2 backend is significantly faster than in prior releases.

• When rendering semi-translucent geometry in parallel, added a new option called “Use Data Partitions”. For unstructured grids and polydata this option will skip the redistribution of points and cells of a data set that was previously needed in order to properly perform depth-sorting for correct rendering. This can dramatically increase the parallel rendering performance. This option requires that all visible data sets in the view have the same partitioning in order to get the rendered view correct. The default setting for this is to have “Use Data Partitions” set to off since in general the partitions will not coincide and the rendered view will be incorrect.

• Mesa 13.0 is now used in Kitware’s Linux distributions of ParaView to benefit from significant speedups resulting from optimizations to Intel’s OpenSWR engine.

Additional Enhancements

• Reloading data files: With this release, we now support refreshing or forcing a reader to reload all data files. This enables updating the visualization based on any changes to the files, e.g., the addition of new time steps. Use the Edit > Reload Files menu option to force the active reader to reload all data files.

• The Ruler source has been revamped. In addition to indicating the location of the end points and then showing the distance on the Properties Panel, the new changes allow you to show the Ruler in any Render View. Using the Display properties on the Properties Panel, you can control its appearance including font, color, and graduation resolution.

• Extract Time Steps filter: This filter can extract the specified time steps from its input dataset. This is useful for cases where one wishes to process only a subset of the input time steps.

• Assemble time steps into a multiblock dataset: By default, a file series is considered to represent a collection of time steps. The new Group Time Steps filter lets you assemble the data set at each time step into a single multiblock dataset.

• Line Widget improvements: Improvements have been made to the line widget in ParaView to make it more user friendly.

• The ParaView application name on Mac OS X now has version information to support side-by-side installation of more than one ParaView version.

• Quoted array names in Calculator: Array names may contain units inside parentheses, e.g., “Velocity (m/s)”. When they do, they are unavailable in the Calculator because the parentheses and forward slash are interpreted as part of an expression rather than as a variable. To address this, ParaView 5.2 adds support for using quotation marks around such names so that they are interpreted as variables.

• Resample With Dataset Filter: This filter is intended to replace the probe filter. It can resample one multiblock dataset of any type,on to another multiblock dataset of any type. This filter uses DIY2 framework for efficient parallel implementation.

ParaViewWeb

ParaView 5.2 includes the latest ParaViewWeb – Visualizer and LightViz applications which takes advantage of the new ParaViewWeb library.

Cinema

ParaView’s export for deferred rendering browsable databases, a.k.a. Cinema, has been updated. This newest version, code named “Chaplin”, has a significantly expanded camera model and more accurate direct-to-float value-rendered images. The new camera model encapsulates complete camera reference frames, which allows Cinema to optimize away redundant snapshots and to be more expressive. For example we now support both inward and outward facing cameras with roll and object tracking and the infrastructure can support others. The direct-to-float rendering relies on OpenGL floating-point textures to make rasters of unmodified data array values. This overcomes a number of precision and accuracy issues in the older approach.

ParaView 5.1.2 (July 2016)

ParaView 5.1.2 is now available for download. It is a patch release that fixes a few critical issues noticed in ParaView 5.1.0.

This release include the following major fixes:

• Rendering translucent geometries: The depth peeling code was revamped for 5.1.0 which introduced two issues: first, it didn’t work as expected in client-server configurations when rendering remotely; second, it had issues with multiple windows/views were present. Both these issues are now fixed. A new environment variable, VTK_USE_LEGACY_DEPTH_PEELING is also added to force using the older version of the depth peeling code.
• Exodus reader: A bug in Exodus reader was causing the reader to improperly read files with no timesteps. That should now be fixed.
• Minimum CMake version: The minimum CMake version needed to compile ParaView has now been reduced to 3.3.

A few other minor fixes/improvements include:

• Fixed the “?” button to show filter documentation.
• Add option to Ghost Cells Generator filter to specify the number of ghost levels to generate.
• Cinema SpecB was not revolving the camera around the data centroid, as expected. Fixed that.
• Added a Catalyst example for the new zero-copy array class.
• Fixed Examples/Catalyst/PythonFullExample when running with pvpython.

ParaView 5.1.0 (June 2016)

ParaView 5.1.0 is now available for download. A complete list of issues addressed by this release is available on the bug tracer. Some of the major highlights of this release are as follows:

OSPRay

ParaView now comes with a built in ray traced rendering capability. Hit the Enable OSPRay checkbox at the bottom of the Properties tab to switch back and forth between OpenGL rasterization and Intel® OSPRay ray tracing. The new capability improves upon LANL’s earlier pvManta plugin and TACC’s pvOSPRay plugin in that it is easier to use (no really – just hit the button), is more compliant with VTK’s full complement of drawing and coloring modes, is better tested, and is available on Linux, Mac and Windows operating systems. Like its predecessors the new interface draws implicit spheres and cylinders for points and lines but these can now be scaled individually by point aligned scalar values. This is especially effective when used in concert with ambient occlusion shading. The renderer is quite fast because it is optimized to put the parallel capabilities of modern CPUs to use. Being a ray tracer it naturally exhibits frame rates upon camera motion that are largely insensitive to geometric complexity for ray cast quality rendering.

Interpolating Point Clouds

New in this release is a collection of filters under the “Point Interpolation” category that can be used to interpolate point clouds to various types of meshes such as a line, a plane or a regular volume. A wide array of interpolation kernels are supported including Voronoi, Shepard and SPH (smoothed particle hydrodynamics).

Generic Arrays

The zero-copy infrastructure to pass data arrays with arbitrary memory layouts to Catalyst has been refactored to minimize runtime overhead when accessing such arrays in filters. This new mechanism is called “generic arrays”. For those interested in knowing more, please refer to this page.

X-Ray View (aka Interactive View Link)

This new feature allows users to render picture-in-picture visualizations, where contents from one view can be shown in another view within an interactable box. To use this, simply use the same mechanism as linking cameras between two views, just make sure you check the Interactive View Link checkbox.

Resampling to Image

For large unstructured grids, it is often faster to resample the whole unstructured grid to a regular grid and then use that for doing operations like contouring, volume rendering, etc. This release includes a new Resample to Image filter that can do this resampling to image operation efficiently, even when data is distributed among several ranks. Under the covers, this filter uses DIY2, a parallel block-parallel library for implementing scalable algorithms.

Welcome Screen

On starting ParaView, users will now be greeted with a welcome screen that offers quick links to resources that are helpful for getting started with ParaView. This includes links to a new brief two-page Getting Started Guide and an example visualizations dialog.

Catalyst

As with any release, several little tweaks have gone into this release to improve Catalyst. Including:

• Disabling compression of PNG output images. For scaling tests with Catalyst we found that most of the in situ processing time was spent in compressing the PNG output file on Mira at Argonne National Laboratory, an IBM BG/Q.
• Improving Catalyst initialization times through using the newly created vtkPSystemTools and vtkPDirectory classes to efficiently do file system introspection in parallel. See this blog for more details.
• Reducing empty files generated by parallel VTK XML writers. Parallel VTK XML writers no longer writer out any files on ranks with empty datasets. This can drastically reduce the files written out when saving extracts from filters such as contour, or slice since often a large number of ranks end up being empty.

Cinema

ParaView’s Cinema export capabilities continue to improve. The Cinema export dialog now gives you better control over what datasets to export and lets you choose the arrays on those datasets to export. Also, Cinema’s naming conventions were made more readable and changed from values to indexes to eliminate precision problems.

Miscellaneous

Here are some of the nifty little features that went in this release:

• You can rename views. Just right click on any view’s title bar and select Rename to rename a view. The new name of course gets saved in state files, accessible through Python API, and all that jazz!
• 3D Widgets (or interactive widgets) were refactored to be nothing more than custom panel widgets. This makes it a whole lot easier for plugins to use interactive widgets to change properties on their filters or even add new types of their own.
• Performance when using data tooltips is now improved. We now cache information picking data structures until the view is interacted with this making the tool useful for larger datasets.
• Axes Grid now replaces Cube Axes which is no longer available. We’ve also cleaned up miscellaneous issues with the Axes Grid e.g. not working well in parallel projection or when volume rendering was being used.
• When showing composite datasets including multiblock datasets in spreadsheet view, traditionally, we only showed one block at a time. Now you can select multiple blocks or show all blocks at one time if you choose.
• A new Catalyst edition named HostTools is now available. This edition is useful when cross compiling either ParaView or any other Catalyst edition. Simply build this edition instead of the whole ParaView source to build the build tools or host tools needed to cross compile ParaView.
• PLY writer now supports exporting color information in addition to the geometry. This will make it easier to export geometries from ParaView to be imported into other stylistic rendering tools.
• Issues with rendering molecular datasets with OpenGL2 backend are now fixed.
• Plot3D reader now supports reading Overflow files that use record delimiters and where data blocks were split between multiple sub-records.
• The Open File dialog on Mac has more useful user directories listed in the special directories listed, including the home, Desktop, Documents, and Downloads directories.
• Color map-specific presets are restored when color maps are reset to the default.

Developer Notes

Binaries on paraview.org are now compiled with C++11. It is possible that externally developed plugins will now need to be compiled with C++11 as well to be compatible with Kitware’s binary packages.

Remember to peruse the major API changes page for changes that could potentially affect your ParaView based applications and plugins. For Python API changes, refer to this page.

This will be the very last release with pqProxyPanel and subclasses (for real this time). This release already prints out a visible warning message as soon as such a panel is encountered.

ParaView 5.0.1 (March 2016)

ParaView 5.0.1 is now available for download. This is a patch release that addresses some critical issues reported in the 5.0.0 release. Since this is a patch release, users using ParaView in client-server configurations can continue to use a 5.0.0 server with a 5.0.1 client if necessary (but not vice versa), although using 5.0.1 server is highly recommended.

Some of the issues addressed by this release are:

• Remote rendering with translucent geometry or volume rendering had artifacts due to the image compression algorithm used for delivering rendered images to the client. This is now fixed by adding a new compression algorithm (LZ4). LZ4 is now the default compression algorithm used for delivering images in client-server mode, instead of SQUIRT.
• ‘Ray Cast Only’ option was accidentally removed from the available volume mapper choices when volume rendering 3D image datasets. This has been fixed.
• Fixed Axes Grid disappearing when using parallel projection.
• Arrays from Field Data were accidentally being listed in array selection widgets for filters like Threshold. Fixed that.
• Fixed run-time issues with executing Python scripts generated using ParaView’s tracing capabilities when the pipeline had multiple output ports.
• Several fixes for volume rendering have gone into this release including fixing issues with volume rendering using cell data arrays.

For a complete set of changes merged into this release, please refer to the Gitlab page and the bug tracker.

Besides 64-bit binaries for Linux, OsX and Windows, we have brought back the 32-bit Windows binaries with this release. The 64-bit Windows binaries are available in two flavors: without MPI and with MPI. The binaries with MPI require that Microsoft MPI is already installed on the target system.

ParaView 5.0.0 (January 2016)

ParaView 5.0.0 is now available for download. This marks the beginning of the ParaView 5.0 series, a long away from the first release 0.2.0 tagged in Dec 2001! Here are some of the major highlights.

New Rendering Engine

This release introduces a brand new rendering backend that the team has been putting together for the past several months. VTK’s rendering engine has received a major rewrite to adopt modern OpenGL APIs and design patterns. Targeted for modern GPUs, the rendering engine has almost all of the capabilities of the old engine, while showing significant performance improvements for both polygonal and volumetric rendering. ParaView now enables using this new rendering engine. Binaries distributed on paraview.org are built with this rendering engine enabled. When building from source, simply set the VTK_RENDERING_BACKEND CMake variable to OpenGL2 to use this new rendering engine. When using this rendering engine, however, ParaView requires OpenGL 3.2 Core context. For older cards and rendering targets, the old rendering backend is still supported. Alternatively, you can choose to use one of the software rendering options that we’ll discuss next.

OpenSWR and Mesa support

Intel has been developing OpenSWR, a high performance, highly scalable OpenGL compatible software rasterizer that allows use of unmodified visualization software. Designed for cases where the GPU hardware isn’t available or is limiting, OpenSWR runs on anything from laptops, to workstations, to compute nodes in HPC systems. Initial public release (alpha) of Intel’s Mesa + OpenSWR integration work is now available and we have included binaries for the same in our ParaView binaries for Linux. The OpenSWR binaries packaged require AVX or AVX2 support. For older CPUs, a LLVM-pipe based Mesa binary is also included. You can use command line options for any of the executables to pick one of the 3 available OpenGL implementations.

To pick a Mesa implementation you can use the following command line options:

 # Pick Mesa software rendering with llvmpipe
 > paraview --mesa-llvm
 
 # Pick Mesa with OpenSWR and AVX instruction set
 > paraview -mesa-swr-avx
 
 # Pick Mesa with OpenSWR and AVX2 instruction set
 > paraview -mesa-swr-avx2

To change the default OpenGL implementation for subsequent launches without providing command line arguments, you can add a file $HOME/.config/ParaView/ParaViewMesaConfig.ini with a single line as mesa-llvm, mesa-swr-avx or mesa-swr-avx2. The command line options always override the value specified in this config file. To pick the native system OpenGL drivers, you can use the --native command line argument. Note that OpenSWR+Mesa is still in alpha and is intended for testing and non-production use.

OSPray

OSPRay is an open source, scalable, and portable ray tracing engine for high-performance, high-fidelity visualization on Intel CPUs. Still in alpha stage, this release of ParaView includes the pvOSPray plugin in our Linux binaries for testing. Simply load this plugin and create the OSPRay Rendered 3D View instead of the usual Render View. Additional Display and View properties are available when using this view that allow controlling parameters like shadows and material properties.

Interactive picking with tooltips on hover

Previously, retrieving information about a data point could be quite a chore: you needed to select the point and then locate this selected point in the spreadsheet view. This release makes this a little easier. Simply click the button in the Render View tool bar and hover over your dataset to see a tooltip with information about the data at the closet point.

Linking selections between different sources

When a dataset from a single source is shown in multiple views, ParaView always showed the selected elements from that dataset in all views. With this release, we extend this mechanism to allow linking of selections between datasets from different sources i.e. selecting cell from a dataset can also highlight cells from another dataset that it is linked to.

Off-screen rendering with EGL

The Native Platform Interface (EGL) provides means to render to a native windowing system, such as Android, X Windows or Microsoft Windows, or to an off-screen buffer. We enable the ParaView command line executables (e.g. pvserver, pvbatch, pvpython) to render to an EGL off-screen buffer. With this work, we allow server-side hardware-accelerated rendering without the need to install a windowing system.

Community Atmosphere Model (Cam5) Catalyst Adaptor

Catalyst is a lightweight version of the ParaView server designed to be directly embedded into parallel simulations to perform in-situ analysis at run-time. In this release of ParaView, we provide a Cam5 Catalyst Adaptor which enables in-situ analysis for the Community Atmosphere Model simulation.

Accelerated Algorithms plug-in

As a teaser to some of the new filters that will start leveraging your many core systems to their max, we have added a plugin that exposes a few of these. This new plug-in includes algorithms designed to be highly scalable for large data by better using many core systems via Threading Building Blocks (TBB). We include Flying Edges 2D and Flying Edges 3D that generate isosurfaces from 2D and 3D data and Flying Edges Plane Cutter that cuts a volume with a single plane. For more information about the implementation of these algorithms see the paper "Flying Edges: A High-Performance Scalable Isocontouring Algorithm" by Schroeder, Maynard, Geveci. Proc. of LDAV 2015. Chicago, IL. Future releases will make it so that such accelerated filers are automatically used by ParaView in place of standard filters where ever possible.

ParaView 4.4 (September 2015)

ParaView 4.4.0 is now available for download. This is planned to be last major release in the 4 series with ParaView 5.0 to be release in near term with totally rewritten, modern rendering backend. A thorough list of over 160 issues and feature requests addressed by this release can be found on the ParaView bug tracker. Some of the major highlights of this release are as follows.

Axes Grid

This release introduces a new annotation type: Axes Grid. Axes Grid can is designed as Cube Axes replacement that can be used to render a grid for the coordinate axes. With improved labelling and formatting capabilities, Axes Grid is designed to completely replace Cube Axes in coming releases.

Color maps

Several new color maps have been added that designed through close collaboration between COSIM climate modelers at LANL, and artist Francesca Samsel. The colormaps move through changes in hue, saturation and value to create a longer line through color-space.

Quartile Chart View

Quartile Chart View makes it easier to visualize summaries for values from multiple selected cells or points over time using the Plot Selection Over Time filter.

Selection enhancements

A multitude of selection enhancements have gone into this release. Interactive selection allows users to interactively select and label elements in a dataset by simply moving their mouse pointer over the visualization. Modifier buttons make it easier to add/subtract selected elements even in the Render View. Finally, Select Points On will find the closest point, retiring the need to rubber band select points.

Multiblock enhancements

Multiblock datasets are now automatically colored so that it’s easier to distinguish different blocks. Furthermore, the Multiblock Inspector reflects this coloring and allows users to override block colors and opacities as needed.

Display only available annotated values in the data set

An option has been added to the the Color Map Editor when interpreting values as categories to show only colors for annotated values actually in the data set. The data range concept has been extended to categorical data values to represent the list of categories in the data set. Updating the data range updates the colors displayed in the scalar bar.

Scalar bar improvements

Scalar bars used to automatically change orientation based on their placement in the view. The orientation can now be fixed to enable greater control of their placement. A bug that sometimes made setting a desired font size difficult or impossible has been fixed. The default number of digits of precision has also been changed from 20 to 6, given more readable scalar bar labels. As a side note, a brand new implementation for the scalar bar is currently underway, so stay tuned!

Improvements to scalar coloring

A new setting makes it possible to set a list of regular expressions defining array names that should not be displayed in the list of color arrays. This makes it easier to avoid cluttering the UI with internal arrays.

Furthermore, the Choose Preset dialog was completely revamped. It now allows searching for present using their name. Also the format for color preset files was changed from XML to a simpler JSON. Although importing older XML files is still supported, color presets can only be exported using the new JSON format.

Lightweight Periodic Dataset Generation

New in this release, Angular Periodic Filter allows users to generate an output dataset from a periodic block provided as the input with minimal memory overhead.

Ability to save a default color map for a named array

It is now possible to save a default color map for an array with a particular name so that any time an object is first colored by that array, the default for that array will be used.

Snap Spline Source/Poly Line Source points to surfaces

Points in Spline Source and Poly Line Source can be snapped to surfaces with the ‘p’ key. Select the point in the table in the Properties panel and type ‘p’ while hovering the mouse cursor over a point on the surface to snap the point to the surface.

Simplified Copy/Paste

Copy/Paste for copying filter properties has been supported in ParaView for several releases. In this releases, we made it easier to access (using buttons on the Properties panel) and extended the ability to including display and view properties.

Simply use the Copy/Paste to copy parameter values between filters, views, etc.

Reading image stacks as volume

To better handle tomography use-cases, we now support opening image stacks, e.g. a series of tiff files, as a 3D volume rather than a temporal dataset. On opening an image file series, users can choose to treat the dataset as a 3D volume using options on Properties panel.

ParaView 4.3.1 (January 2015)

ParaView 4.3.1 is now available for download. The complete list of over 70 issues resolved, including some of the critical ones detected in 4.2, can be found on the ParaView bug tracker.

Some of the major highlights of this release are as follows:

ParaView User’s Guide

A thoroughly revised version of the ParaView Guide is being prepared for publishing. The guide is being distributed as follows: A CC versioned PDF version of the Guide is now freely available for download from the ParaView download page (under Data, Documentation, and Tutorials category). Full color as well as B/W printed versions of the Guide are available for purchase. Besides the open-source parts of the Guide, this printed version includes three additional chapters that cover several domain specific use-cases and case-studies including CFD, Astrophysics, Climate, and VR. The printed versions will be available within the next few weeks. Unlike in the past where the printed versions of the Guide would lag behind the ParaView releases, we are experimenting with a new approach which enables us to update all versions of the guide as frequently as the ParaView releases themselves.

Orthographic Slice View

A new version of the Quad View plugin is now available as a standard view in ParaView, named Orthographic Slice View. This view makes it easy to look at axis aligned slices in any dataset.

Map floating point arrays to colors

This version removes the requirement that only unsigned-char arrays can be mapped to colors directly without using a color transfer function. Three or four component floating point arrays in the range [0.0, 1.0] can now be directly interpreted as colors. Simply uncheck the Map Scalars checkbox on the Properties panel.

Color mapping by string arrays

Coloring by string arrays is possible when the color map option "Interpret Values As Categories" is enabled and a set of annotations whose values are strings in the data array is defined. As with other cases where values are interpreted as categories, a set of active values can be obtained automatically from the data and defined as annotations using the tools in the Color Map Editor's Annotations section. See the blog post about this feature for more details.

Color mapping by field data

You can now color data sets in ParaView by the value of a tuple in a field data array associated with the data set. Field data arrays in a data set now appear in the list of data arrays available to select for coloring. If a field data array is chosen, the first tuple in the array will be used to determine the color of the entire surface of the object being visualized. Tuples may have more than one component, in which case a specific element of the tuple can be selected (similar to how X, Y, or Z components can be selected for vectors) or the magnitude of the tuple can be selected instead. See the blog post for more details.

Adding active values from all visible objects

A new button in the Color Map Editor enables adding active values from all visible objects that are being colored by the array with the same name as the array coloring the active pipeline object.

Out-of-range colors

Prior to this release, values above the range of a color map were set to the color assigned to the maximum value. Likewise, values below the range of a color map were set to the color assigned to the minimum value. In this version of ParaView, you can now optionally set specific colors for values above and below the color map range.

Note to plugin/custom application developers

Please note that this will be the last release in which old style panels i.e. pqObjectPanel and subclasses will continue to work. Starting next release, all those classes will be removed.

See blog post for more details.

ParaView 4.2 (September 2014)

ParaView 4.2.0 is now available to download. The complete list of over 200 issues resolved for this release can be found the ParaView Bug Tracker. Some of major highlights of this release are as follows:

Introducing ParaView Cinema

The idea behind Cinema is to process large data in either batch mode or in-situ using Catalyst to produce smaller data products which could then be viewed in a Web environment while allowing some interactivity and exploration freedom. This new framework is now part of ParaView as additional Python modules will allow dynamic and interactive data exploration within a web environment.

Expanded Properties panel

Continuing the process of avoiding users to have to switch between panels, which started with combining the Properties and Display panels into one, in 4.2 the View properties are now accessible from the Properties panel itself. Of course, some users may still prefer to have separate panels for each. For those, we have added a mode to customize this as well.

Application Settings

The infrastructure for managing user preferences and application settings was refactored from ground up. You can not only only change the configuration options previously exposed through the Settings dialog, but also change the default values for properties for any pipeline module including readers, filters, views and displays.

Not to be left behind, the Settings dialog was also redesigned to follow the now increasingly ubiquitous panel design with default/advanced view modes and searching capabilities.

Improved Python scripting and tracing

The Python tracing infrastructure received a much needed facelift in this release. Several changes to the underpinnings of the ParaView application logic now make it possible for sharing application logic between the graphical and Python-based applications. Thus, performing operations such as setting up color maps, rescaling color maps, creating views and displays, initializing filter defaults are now consistent between the two modes. Furthermore, tracing was made more robust are reliable to include working with color maps, multiple views, etc. Multiple tracing modes allow you to control the trace verbosity, making tracing a useful tool in learning ParaView’s Python API.

Improved NumPy integration

For users of Programmable Filter, Programmable Source, scripting become easier with improved NumPy integration. Writing NumPy expressions that work with distributed and/or composite datasets is now greatly simplified. Refer to the series of blog posts for more details starting with Improved VTK - numpy integration. Improved NumPy support also means improvements to Python Calculator and Find Data mechanism. For the first time, global operations like max(TEMP), min(Pres) are supported and work across ranks and data blocks.

Additional color legend options

The color legend has a slimmer default width when in the vertical orientation. The ranges are now displayed in scientific notation format, which can be customized, and have been moved to the same side as the intermediate numeric labels. Optionally, the numeric labels and tick marks can now be moved to the left side. Additionally, justification options for the title have been added (left, centered, and right). Tick marks, tick labels, and range labels may be independently turned off if so desired. All settings for color legends can be saved as custom defaults using the new settings capabilities described under Application Settings above.

User’s guide

The ParaView Book (or User’s guide) is being updated quite extensively. Updated version of the pdf as well as the printed book will be available soon.

ParaView Catalyst improvements

The ParaView Catalyst library can now be initialized without all processes by passing in the desired communicator to be used. The ParaView Catalyst script pipeline is now read only by process 0 and broadcast to all of the other processes.

ParaView Catalyst Live

ParaView Catalyst is a library that adds ParaView analysis and visualization capabilities to a simulation program. Furthermore, Catalyst can exchange data with a remote ParaView enabling easy inspection of simulation status and modification of analysis and visualization parameters. We call this connection ParaView Catalyst Live. For more information about Catalyst Live see the Introduction to ParaView Catalyst Live blog post.

ParaView Web improvements

The main ParaViewWeb application had a facelift with new features and capabilities. It is becoming more flexible and getting closer to the actual ParaView Qt application UI philosophy.

Blog posts

As an experiment, we have been writing blog posts documenting new features as they are developed -- something we will continue to do in future to keep the community updated and get early feedback.

Refer to the blog post for details.

ParaView 4.1.0 (January 2014)

ParaView 4.1.0 is now available for download (http://paraview.org/paraview/resources/software.php). With about 170 issues resolved, this release includes several bug fixes and feature enhancements. For a detailed list of issues resolved, refer to the change log (http://paraview.org/Bug/changelog_page.php). Some of the notable enhancements in this release are as follows:

Redesigned Color Map Editor panel

This release introduces a completely designed panel for editing color and opacity transfer functions for scalar coloring. The panel, which is now a dockable widget, instead of a popup dialog, makes it easier to edit transfer functions as well as edit labels and annotations on the color legend or scalar bar. This also makes it easier to access some of the functionality introduced in the previous version of ParaView, such as categorical colors. It is now easier to edit transfer functions when using log scaling as the transfer function editor view now switches to log space.

Enhancements to Find Data dialog

Find Data dialog, introduced several versions ago, has quickly become of the main mechanisms for creating new selections. However, until now, if the user created selection using some other mechanism, such as selecting cells in the 3D view, the Find Data dialog could not be used to inspect that selection. One had to use what was called the Selection Inspector. That has now been changed. Find Data dialog has been updated to always show the active selection, no matter how it was created.

Selection Inspector panel has been removed. Selection Inspector was primarily used to control how selections are labelled, their font properties, etc. One can affect these directly from the Find Data dialog or the new Selection Display Inspector which is dockable panel specially designed for picking selection labels, label properties, or showing the selection frustum for frustum based selections.

Enhancements for interactions with Plots

Inspired by plots in matplotlib, individual axes in line and bar charts can now be zoomed by right-clicking and dragging along the x- or y- axis. Of course, one can still drag diagonally to scale both axes as before. Also the the user interactions for making new selections in line chart view have been cleaned up to be more consistent with the render view.

Support for Python-based views

This release adds mechanisms to enable Python developers to integrate views that use libraries such as matplotlib for rendering. This will make it possible to take ParaView’s charting capabilities even further. More details on how to create such views can be found on Kitware blog (http://www.kitware.com/blog/home/post/588).

ParaView Catalyst: Zero-Copy infrastructure for transferring data

A set of experimental interfaces have been added for reusing simulation memory in portions of a Catalyst pipeline. A vtkMappedDataArray subclass may be used for attribute/coordinate arrays, and vtkMappedUnstructuredGrid is used for dataset topologies. More information can be found at http://www.paraview.org/Wiki/CoProcessing#Experimental:_Reusing_simulation_memory.

ParaView Catalyst: Editions

Several new editions of ParaView Catalyst are now available for download and are routinely built and tested. These editions are:

Edition Name	Details
Base	minimal set of dependencies needed for Catalyst
Base-Python	Base with Python support
Essentials	Base + dependencies needed for Calculator, Contour, Clip, Cut and Glyph filters.
Essentials-Python	Essentials with Python support
Extras	Essentials + dependencies needed for ExtractHistogram, WarpScalar, WarpVector, IntegrateAttributes, Extract Surface filters.
Extras-Python	Extras with Python support

SurfaceLIC and support for Parallel Rendering

One of the notable community contributions for this release includes extensions to the ParaView Line Integral Convolution contributed by Lawrence Berkeley National Laboratory (LBNL). Details can be found on the Wiki (http://paraview.org/Wiki/ParaView/Line_Integral_Convolution). The implementation has been designed to work with composite data in parallel and includes a number of customizations that facilitate interactive data exploration.

Updates to ParaViewWeb

ParaViewWeb was integrated into ParaView binaries in the previous release. This release includes several fixes and enhancements to simplify use and deployment as well as updates to the WebGL rendering support. This implementation supports modern browsers with WebSocket capabilities including Safari 6+, Chrome 14+, Firefox 11+ and IE 10+.

As always, we look forward to your feedback (http://paraview.uservoice.com). Also stay tuned to the Kitware Blog (http://www.kitware.com/blog/) for more details on Catalyst and ParaViewWeb.

The ParaView Team

ParaView 4.0.1 (June 2013)

ParaView 4.0.1 is now available for download (http://paraview.org/paraview/resources/software.php). This release marks the first change in the major version number since 2007. Unlike the change from 2 to 3, however, this release is not a major departure from the 3 series, but marks a milestone in the gradual progression of ParaView UI and framework since 2007. These notes highlight some of the major enhacements in this version that addresses over 100 issues since the most recent release (http://paraview.org/Bug/changelog_page.php). ParaView 4.0.1 is based on VTK 6.0 and hence includes all the fixes and enhancements that went into the VTK 6.0 release.

Enhancements for Visualizing Multi-block Datasets

This release introduces a new way for interacting with multi-block datasets, making it easier to change display parameters such as visibility, color, and opacity for multi-block datasets. Using the Multi-Block Inspector, users can now specify such properties on a per-block basis. By treating the multi-block hierarchy as a basic scene-graph, properties specifications can be inherited, thus avoiding the need to explicitly specify overrides for all blocks.

Block properties can also be changed using the context menu in the 3D view. By selecting multiple blocks, one can change properties for all the selected blocks using the context menu. Refer to this blog post to get started (http://www.kitware.com/blog/home/post/503).

Enhancements to the Properties Panel

The Properties panel has been undergoing changes in the past few releases. This release includes further cleanups, bug-fixes and enhancements including a newer and cleaner look for the Properties panel with the ability to group widgets based on functionality. The plugin framework has now been extended to enable users to add custom widgets for the new properties panel. Refer to this blog post covering how to effectively use the new panel (http://www.kitware.com/blog/home/post/491). Developers are referred to ParaView Wiki (http://paraview.org/Wiki/ParaView/Properties_Panel) for additional details.

Extended annotations with mathtext

One of the most requested features on ParaView User Voice (http://paraview.uservoice.com) was the ability to add mathematical markup to annotation text. ParaView can now use the equation rendering support in the matplotlib package to generate mathematical equations in selected text fields. The support for mathtext was added in 3.98 and has been expanded in this release to include chart titles, scalar bar title and labels, along with text sources. ParaView binaries come bundled with matplotlib. Siimply use $<math-text>$ as the text to use. Anything containing the $...$ symbols will be treated as math-text and rendered using matplotlib. Refer to this blog post (http://www.kitware.com/blog/home/post/509).

Exporting vector graphics

One of the most requested features on ParaView User Voice (http://paraview.uservoice.com) was to add support for vector graphics. With this release, it is now possible to export scenes from 3D views and charts as postscript, eps, pdf, or svg vector graphics. All text and annotations such as scalar bars, cube-axes, and curves in charts are exported as vector graphics, thus ensuring crisp reproduction for publications. 3D surfaces and volumes, however, must remain embedded as a rasterized image in the resulting output file. Refer to this blog post for more details (http://www.kitware.com/blog/home/post/508).

Completely redesigned ParaViewWeb

Using Web-based technologies for 3D interactive visualization is now easier than ever before with the totally redesigned ParaViewWeb. ParaViewWeb is a collection of components that enables the use of ParaView's visualization and data analysis capabilities within Web applications and is now simply a part of ParaView source (and binary) packages. Using the latest HTML 5.0 based technologies, such as WebSocket, and WebGL, ParaViewWeb enables communication with a ParaView server running on a remote visualization node or cluster using a lightweight JavaScript API. Using this API, Web applications can easily embed interactive 3D visualization components. Application developers can write simple Python scripts to extend the server capabilities including creating custom visualization pipelines. Updated documentation and examples coming soon, so stay tuned.

Enhancement to CoProcessing Modules

ParaView’s CoProcessing support has undergone several usability improvements with the ability to build adapters externally, and cleanups to the Python coprocessing modules and scripts. Additional details will soon be available in form a Catalyst/CoProcessing Users Guide in the near future.

Improvements to Scalar Bar (Color Legend)

We have added several new enhancements to scalar bar in this release. Besides general improvements in the appearance and label rendering, the scalar bar now has the ability to accept MathText (similar to LaTeX) for the title, subtitle, and annotation text. Similar to including MathText in chart titles and text sources in previous release, any text that enclosed within dollar ($) signs, ($...$) will be presumed to be MathText. This requires Python support with matplotlib available, which is included in the distributed binaries. You can now include Greek letters and other math symbols in your legend.

Another new feature is that colormaps may now be marked to indicate that their domains are ratio or interval-scaled (i.e., continuous, as in previous versions of ParaView) or categorical (also called nominal). Categorical colormaps are not shown as a continuous range of colors but as a discrete set of color swatches. You may set the text to accompany each value in the Annotations tab of the color legend editor. Arrays that hold categorical data (where there are no more than 32 unique values stored across all array entries) will automatically have annotations added when you open the color legend editor. When switching a colormap between ratio and categorical modes, the color set-points in the continuous color bar are used as the colors to assign to categorical values; the default blue-to-red colormap has only 2 color set-points, so if you switch from this preset to a categorical colormap, you will see only 2 color swatches: red and blue. However, another new feature is that several categorical colormap presets have been added, including the Brewer palettes. You may wish to choose one of these presets (which will automatically switch the colormap to categorical mode).

Documentation

Starting with this release, we will now be providing online documentation for the Python and JavaScript API along with the C++ API online. The documentation can be accessed from http://www.paraview.org/paraview/help/api-documentation.html.

Nightly binaries

For users interested into trying out the latest and greatest developments for ParaView as the development team works on them without building from source, they can download the nightly builds from the ParaView download page (http://paraview.org//paraview/resources/software.php).

As always, we look forward to your feedback (http://paraview.uservoice.com). Also stay tuned to the Kitware Blog (http://www.kitware.com/blog/) for more details on Catalyst and ParaViewWeb.

ParaView 3.98.1 (February 2013)

ParaView 3.98.1 is now available for download. This is a bug-fix release, primarily intended to polish some of the new features introduced in ParaView 3.98.0. The detailed list of issues addressed by this release can be found on bug-tracker.

Some of the major fixes are:

• Math-text in annotation: ParaView 3.98.0 introduced support to add annotations with math-text. This release extends on that capability to support math-text in several annotations including Text source, chart titles, scalar bars. Simply use $<math-text>$ as the text to use. Anything within the $...$ symbols will be treated as math-text and rendered using matplotlib.

• Rendering translucent geometries in Parallel: For certain datasets, especially, those with a cell containing more than 512 points, rendering translucent geometries would cause freezes and segfaults in parallel. This issue has been addressed.

• This release also minimizes progress messages that had the potential to clog MPI channels especially for large runs.

• Issues with OSX Mountain Lion: This release addresses the OSX Mountain Lion runtime issue that seemed to be a side effect of the number of libraries being loaded/linked.

Annotations with math-text in ParaView 3.98.1 (using matplotlib)

ParaView 3.98.0 (December 2012)

ParaView 3.98.0 is now available for download (http://paraview.org/paraview/resources/software.php). This is slated to be the final major release in the 3 series, hence the dramatic change in version number since the last release (3.14.1). If needed, we will have patch release(s) before the 4.0 release. These release notes give a summary of the major changes in this release, which address more than 300 issues (http://paraview.org/Bug/changelog_page.php).

• Exporting to PS/PDF: One of the most requested features on ParaView User Voice (http://paraview.uservoice.com) was to add support for vector graphics. With this release, it is now possible to export scenes from 3D views and charts as postscript, eps, pdf, or svg vector graphics. All text and annotations such as scalar bars, cube-axes, and curves in charts are exported as vector graphics, thus ensuring crisp reproduction for publications. 3D surfaces and volumes, however, must remain embedded as a rasterized image in the resulting output file.

• Math-text in annotations: The second most requested feature on ParaView User Voice (http://paraview.uservoice.com) was the ability to add mathematical markup to annotation text. ParaView can now use the equation rendering support in the matplotlib package to generate mathematical equations in selected text fields. Only categorical scalar bar annotations support this feature at the moment, but future releases will extend this capability to all text fields.

• Transparent surfaces: Another highly requested feature was the ability to specify the opacity mapping when coloring surfaces with scalars, which is added in ParaView 3.98.0. The 'Color Scale Editor' dialog adds the ability to specify the opacity functions for surfaces.

• Redesigned 'Properties' panels: With the 3.98.0 version, we have revamped the panels used to specify filter properties and display parameters. Instead of using separate panels, we now have a combined 'Properties' panel that by default shows a subset of commonly used properties for filters. For more control, users can easily switch to an advanced view. The updated panel also adds the ability to search for properties by name.

• Improved AMR support: AMR (adaptive mesh refinement) data structures were completely redesigned for improved performance and memory efficiency. It is now possible to volume render AMR datasets. Additionally, we have added support for multi-resolution streaming of AMR datasets for adaptive volume rendering.

• Simplified 'Find Data': The 'Find Data' dialog, used for querying datasets, has been simplified with the ability to specify complex queries for advanced users. Commonly used operations such as min, max, and mean are now accessible from the simplified interface.

• New slice-based views: Two new views have been added to simplify data exploration using orthogonal slices: Slice and Quad view. The Slice view allows the user to quickly create, delete, and move any arbitrary slice along a given axis using an interactive user interface. The Quad view enables the user to explore a dataset using three slices that get independently rendered in their own 2D view while a 3D view lets the user see slices’ positions in 3D space.

• Modularization of VTK/ParaView: In the past few months, VTK was restructured to use a modularized approach for building various components of the toolkit. ParaView's build infrastructure was revamped to make use of this. It is now possible to build variants of the ParaView library while picking and choosing modules from VTK that are of interest, while removing those that are not. Thus developers are able to build small, lightweight VTK and ParaView packages ideal for co-processing.

• Improved co-processing: Catalyst (http://catalyst.kitware.com) leverages the VTK and ParaView modularization by allowing users to simplify which parts of VTK and ParaView to link simulation codes to for in situ processing. Note that Catalyst should be considered beta functionality. In addition, the co-processing library was modified to add in extra Python methods that give a cleaner look to the GUI generated scripts. Due to changes in ParaView though, scripts created with ParaView 3.14.1 that generate screenshots will not work with ParaView 3.98. ParaView 3.14.1 generated co-processing scripts that only output extracts (i.e. data files) should work fine with ParaView 3.98.

• This version of ParaView includes an experimental interface to GPGPU processing in Los Alamos National Lab's PISTON (http://viz.lanl.gov/projects/PISTON.html) library. The interface takes the form of a plugin (which must be compiled from source) that exposes Piston's on-GPU implementations of the slice, threshold and iso-contour algorithms while minimizing transfers between the CPU and GPU.

Every release of ParaView includes several excellent contributions from the community, and this release is no different. The 3.98.0 release includes a completely redesigned 'Memory Inspector' panel that can be used to keep track of memory usage across all ParaView processes, including remote processes (thanks to Burlen Loring at Lawrence Berkeley National Laboratory). Moreover, a new ParaView reader plugin for LANL's GMV file format has been added (thanks to Sven Buijssen at TU Dortmund University) that supports a wider set of keywords than the current one from VisItBridge.

ParaView 3.14.1 (April 2012)

ParaView 3.14.1 is now available for download (http://paraview.org/paraview/resources/software.php).

This is bug fix release that includes fixes for ParaView 3.14.0. ParaView 3.14.1 clients can be used to connect with servers running ParaView 3.14.0 and vice-versa. Similarly, plugins built for ParaView 3.14.0 should generally work with ParaView 3.14.1.

The issues that were fixed are as follows:

• 0012924: Paraview 3.12.0 fails to build with zlib 1.2.6, invalid conversion from 'void*' to 'gzFile'
• 0012956: Auto apply, variables don't show up.
• 0012964: View Layout State issue
• 0012969: pvsc option enumeration issues
• 0012970: No way to use netcdf4 with system netcdf
• 0012981: Bug in panning/scaling of top-right axes in charts
• 0012983: HSCTH files not reading timesteps correctly
• 0012984: cherrypick the fix in VTK of vtkPyramid.cxx compute gradient into ParaView
• 0012991: Build problem with nmake and windows
• 0012997: protoc generation doesn't work on Windows with nmake builds.
• 0013012: Errors on FindData
• 0013030: EnSight6Reader incorrect "transient single file format" and "scalar per element"
• 0013033: problems with scalar bar
• 0013048: ContourRepresentation can't override Intialize

Detailed change log can be found at http://paraview.org/Bug/changelog_page.php?version_id=95.

ParaView 3.14.0 (February 2012)

ParaView 3.14.0 is available for download. These notes give a summary of the major additions to this release. (change log).

'Find Data' dialog used to select elements using queries has been totally redesigned. The new design makes it possible to use complex queries to select elements including combining multiple test cases using boolean operations. (details).

A new 'Memory Inspector' panel was added to make it easier for users running on large cluster to identify and debug memory related issues by providing a mechanism to track the memory used on all the nodes (details).

Extending ParaView's charting capabilities, we have added a new scatter plot matrix view, allowing visualization of multiple dimensions of your data in one compact form, allowing you to spot patterns in the small scatter plots, change focus to those plots of interest and perform basic selection (details).

The color editor used to edit lookup tables/color tables used for scalar mapping was completely redesigned to enable editing the color and opacity functions independently. Additionally, one can now specify smoothly varying opacity functions very easily (details). Also, when coloring with an unsigned char array representing RGBA, it's now possible to render polygonal geometry using the opacity specified by the alpha component of the scalar array.

To make it easier to deal with a large number of views at the same time, ParaView now supports creating multiple tabs for placing views. This enables rapid switching of views laid out on a tile-display by simply switching the active tab (details).

With improvements to the view layout framework, it is now possible to change the layout of views using Python (details).

3.14 includes enhancements to the Plugin framework enabling developers to provide documentation for their plugins. The documentation for the plugins shows up in the default application help window accessible from the Tools menu (details)

ParaView Server Configuration Script (pvsc) files is the de-facto mechanism in ParaView to connect to different remote computing sites. With 3.14, we have added a pvsc distribution mechanism that makes it easier for site maintainers and ParaView users alike to distribute/obtain configuration files for different sites (details).

Several other usability enhancements were made to this release. For example, it is now possible to easily copy values such as ranges, bounds, etc. from the information tab, statics inspector, spreadsheet view, to the clipboard. To make it easier to find items in variables lists and trees, one can use Ctrl+F to popup a search widget that searches through the selected widget (details).

Also all inspector panels including information tab, display tab and, properties tab are now dockable.

Netcdf4 has been updated to 4.1.2, making it possible to access hdf5 backed netcdf formats.

This release also includes two new experimental features:

• Collaboration: this adds support to connect multiple clients to the same server (pvserver) for collaborative visualization.
• Multi-Servers: this adds support to the ParaView client to connect to multiple remote servers at the same time to build separate pipelines on the connected servers using the same client.

Note that these are both experimental features and should be considered as 'alpha' (details).

ParaView 3.12.0 (November 2011)

The ParaView team is pleased to announce the availability of the ParaView 3.12.0 Release Candidate 3 binaries for download on the ParaView (http://paraview.org/paraview/resources/software.html). ParaView 3.12 can be considered as a bug-fix release with over 180 issues resolved. The detailed list can be found at http://www.paraview.org/Bug/changelog_page.php?version_id=85.

With Python being one of the preferred means of interacting with ParaView, we've added support to create animation tracks that use Python scripts to build highly customized animations.

Plugins support is one of the strong points of ParaView and with this release, we've made it easier to load deployed plugins on the server processes as well. All distributed plugins are now listed on the client as well as the server side.

The release includes updates to LANL's streaming framework. The multiresolution streaming view now automatically adjusts resolution to match the projected image size. Also, VTK filters are now able to modify meta-information which means they can modify the data while still allowing the streaming framework to cull and prioritize pieces. An example is a new spherical warp filter that projects flat data onto the globe while correctly tracking piece bounding boxes.

Also, there are updates to support users of the cosmology and windblade formats. For example the MaskPoints filter (used to place glyphs and in other places) was updated with new options that improve random sampling in parallel. Likewise VTK's Gaussian Splatter filter is now exposed in ParaView which makes it easy to visualize point set data with imaging filters. The cosmo and windblade readers have also been revised.

This version includes some major changes under the covers. ParaView 3.12 includes improvements to the underpinnings of ParaView ServerManager. The communication layer under the ParaView ServerManager was upgraded to minimize communication as well as making it easier to debug and trace messages being exchanged between client and server. We now use Google Protocol Buffers, for example, to exchange messages between client and server.

In addition, there are several small but notable improvements included in this release for example, the views now use caching to avoid re-renders from repaints due to menus and dialogs popup up on the screen; volume rendering of uniform grids now supports shading; ability to enable specular highlights when using scalar coloring and others.

The updated userguide can be accessed at: http://www.paraview.org/Wiki/ParaView/Users_Guide/Table_Of_Contents Or in PDF form at: http://paraview.org/files/v3.12/ParaView%20Users%20Guide%20v3.12.pdf

The development team has adopted a git-workflow-based development process that is integrated with the ParaView Bug Tracker (http://paraview.org/Bug). The workflow enables us to track every change that goes into ParaView and maintain a stable repository.

We value your feedback. Please use http://paraview.uservoice.com or click on the "Tell us what you think" link on paraview.org to leave your feedback and vote for new features.

ParaView 3.10.1 (April 2011)

ParaView 3.10.1 is a patch release to address a few issues detected in 3.10.0.

ParaView Binaries:

• Fixed crash on 32 bit Windows when opening CGNS files.
• Resolved crash issue when opening Xdmf files on 64 bit Windows.
• Fixed an issue where playing an animation would cause an increase in memory.
• Corrected a performance slowdown when parsing python array calculator expressions.

Development:

• Removed install rule for ParaViewLibraryDepends as it is no longer is being generated.
• Corrected Install rule for vtkPVApplicationComponents that was not exporting correctly causing link errors when compiling the SpreadSheet example on Fedora.
• Removed duplicate vtkVector class that was in ParaView but not used.
• Added exclusions to the wrapping parser that would inadvertently attempt to wrap gl.h which would subsequently cause builds to hang on some systems.

ParaView 3.10.0 (March 2011)

This release features notable developments, including mechanisms to incorporate advanced rendering techniques, improved support for readers and several usability enhancements and bug fixes.

For the 3.10 release, we have added 60 new readers. The new readers include: ANSYS, CGNS, Chombo, Dyna3D, Enzo, Mili, Miranda, Nastran, Pixie, Samrai, Silo, and Tecplot Binary. A full listing of supported readers can be found in the ParaView Users Guide. We also added the ability for developers to create ParaView reader plugins from previously developed VisIt reader plugins. You can find a full guide on how to do this on the VisIt Database Bridge: http://www.paraview.org/Wiki/VisIt_Database_Bridge

With this release we have rewritten the ParaView User's Guide and are making it freely available for the first time. The complete guide can be obtained in the help system or online at: http://paraview.org/Wiki/ParaView/Users_Guide/Table_Of_Contents.

We have included a Python-based calculator which makes it possible to write operations using Python. The Python calculator uses NumPy, which lets you use advanced functions such as gradients, curls, and divergence easily in expressions. Also the NumPy module is packaged in the ParaView binary and is importable from the ParaView Python shell.

There should also be a marked performance improvement for users dealing with large multi-block datasets. We have cleaned up the rendering pipeline to better handle composite datasets, avoiding the appending of all blocks into a single dataset as was done previously.

To better utilize multiple cores on modern multi-core machines, by default ParaView can now run using a parallel server, even for the built-in mode. This enables the use of all the cores for parallel data processing, without requiring the user to start a parallel server. ParaView binaries will also be distributed using an MPI implementation, making this feature available to users by simply downloading the binaries. Since this is an experimental feature, it is off by default, but users can turn it on by checking the Auto-MPI checkbox in the application settings dialog.

Additionally, the 3.10 release includes several usability enhancements. 3D View now supports smart context menus, accessed by right-clicking on any object in the 3D View to change its color, representation, color map and visibility. Left-clicking on an object in the 3D View makes it active in the pipeline browser. Within the spreadsheet view, sorting is now supported and an advanced parallel sorting algorithm ensures that none of the benefits of the spreadsheet view, such as streaming and selection, are sacrificed. Python tracing and macro controls are no longer hidden on the Python shell dialog and instead are now easily found on the Tools menu.

For developers interested in adding support for advanced multi-pass rendering algorithms to ParaView, this release includes a major refactoring of ParaView's rendering pipeline. View and representations have been redesigned and users should see improved performance in client-server mode from reduced interprocess communication during rendering.

LANL's MantaView interactive ray tracing plugin has been restructured to make it easier to use. Version 2.0 of the plugin is now multi-view capable and no longer requires ParaView to be run in a client/server configuration. Similarly both of LANL's streaming aware ParaView derived applications have been merged into ParaView proper in the form of a new View plugin. The underlying streaming algorithms have been rewritten to be more usable and extensible. Both plugins are available in standard binary package for the first time in this release.

For an exhaustive list of the new features and bug-fixes, please refer to the change log at: http://www.paraview.org/Bug/changelog_page.php.

As always, we rely on your feedback to make ParaView better. Please use http://paraview.uservoice.com/ or click on the "Tell us what you think" link on paraview.org to leave your feedback and vote for new features.

ParaView 3.8.1 (Sept 2010)

The ParaView team is pleased to announce the availability of the ParaView 3.8.1 binaries for download on the ParaView download page.

http://paraview.org/paraview/resources/software.html

Release Notes:

ParaView 3.8.1 is a patch release over 3.8.0 with a a small set of improvements. Some of noteworthy improvements/fixes are:

ParaView now comes HDF5 1.8.5. This enables developers to create readers/plugins for ParaView that use newer versions of HDF5 easily. Also we are now including the C++ and the high level (hl) versions of the libraryfor those who wish to use their newer API.

Along the same note the version of NetCDF included in VTK has also been upgraded to version 4.1.1 allowing users to take advantage of the latest enhancements to NetCDF. Additionally the C++ version of the library is now also available.

Among the improvements are two new file formats. The first is a netcdf based reader for MPAS format ocean and atmosphere data sets. The second, available in source form only is a reader plugin that allows ParaView to read multi-resolution wavelet compressed VAPOR data format files. Thanks to John Clyne and Dan Legreca for contributing the VAPOR plugin.

We have improved the support for animation scripting through Python. The new API is more coherant with the rest of ParaView Python API avoid the need for script writers to know the minute details of how to create animations using proxies. Tracing capabilies for animation were also revised.

GPU volume ray cast mapper for voxel datasets now works in tile display mode as well.

In keeping with our on going improvements of the ParaView's charting capabilities, we have included a few more fixes regarding labels and axes placements.

We also cleaned up ParaView build and install rules so that developers don't have to worry about 'rpath' anymore. Also "make install" has been vastly improved on all platforms.

This release also includes a material interface extraction filter thattakes a cell data volume fraction and generates a polydata surface. It also performs connectivity on the particles and generates a particle index as part of the cell data of the output. It computes the volume of each particle from the volume fraction. The filter is accessible from the Material Analysis category in the Filters menu.

Also, CoProcessing/in-situ processing has been added to ParaView. It includes 2 parts: a client side plugin that creates python scripts and a server side library that can be called from a simulation code to output both images and data sets based on the created python script. For more details go to http://paraview.org/Wiki/CoProcessing.

Updated development installers will also follow shortly.

As always, we rely on your feedback to make ParaView better. Please use http://paraview.uservoice.com/ or click on the "Tell us what you think" link on paraview.org to leave your feedback and vote for new features.

ParaView 3.8.0 (May 2010)

Kitware, Sandia National Laboratories and Los Alamos National Laboratory are proud to announce the release of ParaView 3.8.0. The binaries and sources are available for download from the ParaView website (http://www.paraview.org/paraview/resources/software.html). This release includes several performance improvements, bug fixes for users, and plenty of new features for plugin and application developers. We have made it easier to locate cells/points in your dataset using queries. Search the ParaView Wiki for "Find Data using Queries" for more information.

The plugin loading and management dialog was redesigned to make it easier to load plugins. It's now possible to configure plugins to be auto-loaded every time ParaView starts. We've added support for plotting over curves and intersection lines using the filters "Plot On Sorted Lines" and "Plot On Intersection Curves".

A couple of GPU-based rendering/visualization techniques have been incorporated along with GPU-based volume rendering support for 3D image volumes, which is accessible through the "Volume Mapper" option on the Display tab. Support for Line Integral Convolution (LIC) is available as a plugin; this support can be used for visualizing vector fields over arbitrary surfaces.

ParaView now includes (in source form only) an interface to the University of Utah's Manta interactive software ray tracing engine. The Manta plugin provides a new 3D View type which uses Manta instead of OpenGL for rendering. The plugin is primarily being developed for visualization of large datasets on parallel machines. In single processor configuration it has the benefit of allowing realistic rendering effects such as shadows, translucency and reflection.

In terms of performance improvements, we've greatly improved the first render time for datasets with large numbers of blocks. Raw image reading for parallel file systems underwent a major overhaul making it fast and efficient. Options were added to the Settings dialog to fine tune image compression, improving interactivity when remote rendering over connections with varying bandwidths.

After the introducing Python tracing in the previous release, we have expanded the purview of tracing to include selections, lookup tables, and implicit functions.

For climate simulation folks, this release includes support for NetCDF with CF (Climate and Forecast) conventions. For cosmology researchers, the Cosmo plugin has been substantially revised. The major improvement is that the plugin now works in a data parallel fashion, so that it can be used with higher resolution simulation results. We have reintroduced basic support for CAVE rendering which was lost since the major overhaul for ParaView 3.0.

Several new readers have been contributed: WindBlade a reader for wind turbine and fire simulation data, VPIC a reader for particle and cell physics simulation data, and netcdf POP a reader for POP ocean simulation data in a netcdf container format.

AdaptiveParaView, a new experimental application developed using the ParaView application framework is also now available in source format. Like StreamingParaView, AdaptiveParaView processes structured datasets in a piecewise fashion, omitting pieces which are unimportant, in order to make it possible to visualize datasets which do not otherwise fit in RAM. AdaptiveParaView differs from prior work in that it renders pieces in a multi-resolution manner, initially producing low-resolution images and then progressively filling in greater detail within the viewing frustum. This application still contains many experimental features and is not yet documented, but we encourage users to try it out and report bugs and feature requests.

PVBlot is a command tool for batch or interactive processing of Exodus data files. It is provided as a plugin. The commands create various mesh visualzations and XY plots of variable versus time, or variable versus variable. The plugin adds an interactive pvblot console to the ParaView Tools menu. Documentation for PVBlot is built into the tool, just type 'help' or 'help '. The SierraTools plugin provides pvblot-like features but exposes the functionality through toolbar buttons and dialogs in place of text commands.

There are several other fixes including those for charting and plotting, wireframes for quadratic surfaces, and for dealing with temporal ranges.

For developers, this release includes major changes to the core ParaView libraries making it easier to create and deploy custom applications based on the ParaView framework. This enables developers to create applications with fundamentally different workflows than that of ParaView while still leveraging ParaView's parallel processing and large data visualization capabilities. Search for "Writing Custom Applications" on the ParaView Wiki for details.

The plugin framework has undergone an overhaul as well, making it easier to debug issues with loading of plugins as well as support for importing plugins in static applications.

Starting with ParaView 3.8, we will be releasing development binaries for ParaView, which will make it easier for developers to build and distribute plugins that are compatible with the binaries downloaded from our website. These development binaries will be available shortly.

As always, we rely on your feedback to make ParaView better. Please use http://paraview.uservoice.com/ or click on the "Tell us what you think" link on paraview.org to leave your feedback and vote for new features.

ParaView 3.6.2 (Jan 2010)

Kitware, Sandia National Laboratories and Los Alamos National Lab are proud to announce the release of ParaView 3.6.2. The binaries and sources are available for download from the ParaView website (http://www.paraview.org/paraview/resources/software.html). ParaView 3.6.2 contains the following new features and improvements.

The Python interface has been revamped, an exciting new extension to the Paraview Python interface is Python trace. The goal of trace is to generate human readable, not overly verbose, Python scripts that mimic a user's actions in the GUI. See the "Python Trace" article on page 6 of the October 2009 Kitware Source for more details.

ParaView 3.6.2 includes a collection of statistics algorithms. You can compute descriptive statistics (mean, variance, min, max, skewness, kurtosis), compute contingency tables, perform k-means analysis, examine correlations between arrays, and perform principal component analysis on arrays. More information about these filters is available on the ParaView Wiki at http://www.paraview.org/Wiki/Statistical_analysis.

ParaView 3.6.2 includes the VisTrails Provenance Explorer plugin in the Windows and Linux packages. VisTrails is an open-source scientific workflow and provenance management system developed at the University of Utah that provides support for data exploration and visualization. The VisTrails Pplugin brings provenance tracking and many of the benefits of provenance to ParaView users. It automatically and transparently tracks the steps a user followed to create a visualization. In contrast to the traditional undo/redo stack, which is cleared whenever new actions are performed, the plugin captures the complete exploration trail as a user explores different parameters and visualization techniques. A tree-based view of the history of actions allows a user to return to a previous version in an intuitive way, undo bad changes, compare different visualizations, and be reminded of the actions that led to a particular result. Also, there is no limit on the number of operations that can be undone, no matter how far back in the history of the visualization they are. Last, but not least, the history is persistent across sessions. The VisTrails plugin can save all of the information needed to restore any state of the visualization in .vt files, which can be reloaded across ParaView sessions and shared among collaborators. This also allows multiple visualizations to be shared with a single file.

LANL's cosmo plugin is now distributed with ParaView 3.6.2. This plugin allows ParaView to read and process *.cosmo format files, in which particles are described by mass, velocity and identification tags. These particles typically represent stellar masses. The halo finder filter is a friend-of-a-friend particle clustering algorithm. It creates groups containing particles that satisfy a tolerance/threshold linking distance criterion. The cosmology data format, halo finding algorithm, and related (experimental) filter implementations are made possible by the LANL cosmology researchers, the LANL visualization team, and international collaborators.

Mac application bundle and comand line tools are now built as universal binaries (PPC and Intel i386). This simplifies managing ParaView on Mac as now there is only a single binary to download for any architecture.

As always, we rely on your feedback to make ParaView better and powerful. We are experimenting with a new user-feedback mechanism. Please use http://paraview.uservoice.com/ or click on the "Tell us what you think" link of www.paraview.org to leave your feedback and vote for new features.

ParaView 3.6.1 (July 2009)

The ParaView 3.6.1 release is now available for download from the ParaView web site (http://paraview.org). It is also available through CVS; the tag is ParaView-3-6-1. This release includes several new features along with plenty of bug fixes addressing a multitude of usability and stability issues including those affecting parallel volume rendering. For a more exhaustive list, please refer to http://paraview.org/Bug/roadmap_page.php

Based on user feedback, ParaView's Python API has undergone a major overhaul. The new simplified scripting interface makes it easier to write procedural scripts mimicking the steps users would follow when using the GUI to perform tasks such as creating sources, applying filters, etc. Details on the new scripting API can be found on the Paraview Wiki.

We have been experimenting with adding support for additional file formats such as CGNS, Silo, Tecplot using VisIt plugins. Since this is an experimental feature, only the Linux binaries distributed from our website support these new file formats.

ParaView now natively supports tabular data-structures thus improving support for CSV files including importing CSV files as point-sets or structured grids. We have completely redesigned the charting/plotting components with several performance fixes as well as usability improvements. It is possible to plot arrays from arbitrary datasets directly using Plot Data filter. Upon hovering over the plots tooltips are shown which detail the plotted values.

In an effort to better support animations involving the camera, we have added support for specifying camera movements along splines or for orbiting around objects in space. This version has many GUI usability improvements including, but definitely not limited to:

• Color palettes which make it easier to switch between color schemes that are suitable for printing and for screen.
• Improved support for temporal readers and filters.
• Axes annotations and scalar bar for 2D render view.
• Zooming to selected region in 3D view.
• Quick launch for creating sources and filters using Ctrl+Space or Alt+Space.

Apart from these enhancements, ParaView includes a pre-alpha release of OverView, an application developed using the ParaView application framework. OverView is a generalization of the ParaView scientific visualization application designed to support the ingestion, processing and display of informatics data. The ParaView client-server architecture provides a mature framework for performing scalable analysis on distributed memory platforms, and OverView uses these capabilities to analyze informatics problems that are too large for individual workstations. This application still contains many experimental features and is not yet documented, but feel free to try it out and report bugs and feature requests.

StreamingParaView, another application developed using the ParaView application framework. StreamingParaView processes structured datasets in a piecewise fashion, on one or many processors. Because the entire dataset is never loaded into memory at once, StreamingParaView makes it possible to visualize large datasets on machines that have insufficient RAM to do so otherwise. Piece culling, reordering and caching preserve ParaView's normally high interactivity while streaming. This application still contains many experimental features and is not yet documented, but we encourage users to try it out and report bugs and feature requests.

Currently, both OverView and StreamingParaView are available through source alone.

Bugs, feature requests and any questions or issues can be posted to the ParaView Mailing List at paraview@paraview.org.

As always, we rely on your feedback to make ParaView better and powerful. We are experimenting with a new user-feedback mechanism. Please use http://paraview.uservoice.com/ or click on the "Tell us what you think" link of www.paraview.org to leave your feedback and vote for new features.

ParaView 3.4.0 (October 2008)

The ParaView 3.4 release is now available for download from the ParaView web site (http://paraview.org). It is also available through CVS; the tag is ParaView-3-4-0. Since the 3.2 release, we have been focusing on usability and 3.4 contains many improvements and bug fixes.

The major changes since 3.4 are:

• VTK and ParaView are now licensed under the BSD license as opposed to modified BSD.
• The multi*block and AMR support was improved significantly. Almost all filters, spreadsheet view and charts now support these datasets.
• The selection capabilities of ParaView were significantly improved. For details, see Kitware Source, issue 6 or http://paraview.org/Wiki/Data_Selection.
• Some of other improvements and fixes are

New features

• Added support for plotting multiple point/cell values over time.
• Save screenshot now allows saving of all views.
• It is not possible to save higher resolution screenshots.
• Added support for picking end*points of lines widgets (used in plot over line and streamlines) using 'p'.
• Added support for scene exporters. Supported formats are X3D (binary and ascii), VRML 2 and POV (Persistence of Vision Raytracer).
• Added ability to open multiple CTH and Exodus restart files.
• Added temporal statistics filter that can be used to find average, min, max and standard deviation of arrays over time.
• Added support for choosing (picking) custom center of rotation.
• Added volume rendering support for multi*block datasets. The user now chooses which block to volume render.
• Added filter to append all blocks of a multi*block dataset to one unstructured grid. Can be used to volume render the whole multi*block dataset.
• Added support to color by block.
• Added 2D views / slice representation for volumes (vtkImageData).
• Added box and sphere widgets for slicing and clipping.
• Added cube axes that can be used to show scale of a dataset.
• Added support to color by AMR level.
• Added support to turn on/off the visibility of multiple objects. Select multiple objects in the pipeline browser and click on one of the eyeballs.
• Added multiple selection using ctrl (command on Mac). When performing selection after the first time, hold ctrl to add to the existing selection.
• Added "Normal Glyphs" custom filter.
• Added "zoom" to individual arrays in the spreadsheet view. Double*click on the title*bar to activate/deactivate.
• Added support for displaying textures on polygonal data.

Improvements to Existing Features

• Plugin improvements. See the plugin page on the wiki for more information. http://www.paraview.org/Wiki/Plugin_HowTo
• Added option to disable offscreen rendering while saving images. This option should be turned on if ParaView crashes when saving images. This is to get around an OpenGL bug that is on some Linux Intel drivers.
• Added option to disable depth peeling when rendering translucent geometry. Some graphics card drivers claim to support everything that is needed for depth peeling while not implementing them. If you are experience crashes when transparency is on, disable depth peeling.
• Added easily accessible menu to select the component of a vector to color by.
• Added support for plotting more than one component of a vector on the same chart.
• Plot over line now works with multi*block and AMR data.
• CTH reader now combines X, Y and Z velocity components into a vector.
• Added button to rescale to data range in bar charts.
• Changed the default width of the scalar bar to a more reasonable size. Also tweaked the way scalar bar scaling works.
• Improved partial array support (when an array exists only in some of the blocks of a multi*block dataset).
• Added selection support for composite datasets.
• Added chooser for unstructured volume rendering algorithm.
• Added support for selecting array in gradient filter for image data. Removed gradient magnitude. Use gradient + array calculator.
• Many comparative view fixes.
• Many tiled*display fixes.
• Many widgets used a few digit precision for floating point numbers making it impossible to use higher precision. Fixed.

Reader and Writer Improvements

• Added readers for MFIX and Fluent files to the GUI.
• Added support for loading file series from the command line as well as from the recent file menu.
• Added SILO reader. Needs more work. Needs compilation from source due to Silo license (it is not open-source).
• Added support to save multi*block polygonal datasets as a collection of STL or PLY files.
• Added support for file series of XML based VTK files.
• Updated XDMF reader to XDMF 2.

Bug Fixes

• Point coordinates were not shown in the spreadsheet view if there were no point arrays. Fixed.
• Calculator function was not reloaded with state. Fixed.
• Annotation text was not scaling properly when rendering high*resolution animations/images. Fixed.
• Color by menu was not updated in some cases. Fixed.
• CTH reader was not handling missing files gracefully. Fixed.
• Selection inspector could not display labels for global element ids. Fixed.
• Loading state reseted to time step 0, fixed.
• Pipeline was not always updating when time was shifted. Fixed.
• Fixed crash when using Edit *> Delete All.
• Fixed installation with VTK_USE_RPATH on.
• Selection did not work in parallel if compositing was off. Fixed.
• Selection labels were not updated during animation. Fixed.
• Several undo/redo fixes.

ParaView 3.2 (November 2007)

Release notes for 3.1 (development version) and 3.2 can be found here.

ParaView 3.0

Release notes for development snapshots and 3.0 can be found here.

ParaView 2.6

Release notes for ParaView 2.6 can be found here.