Google Summer of Code Final Results

The VTK project saw a boost in development activity over the summer thanks to the Google Summer Of Code program. This is the third year that VTK has participated in the program, where Google pays students to work with experienced mentors on open source projects around the world during their summer break.

We carefully selected six students from a set of twenty five proposals for the VTK project and they all learned a great deal over the summer. Their mentors learned quite a bit too and VTK moved forward because of the research and development that we all did together.

CAD Model and Simulation Spline Visualization

by Lin M with David Thompson

https://gitlab.kitware.com/Lin.Ma/vtk-spline/tree/filter-bezier

The "Splines for Simulation and CAD Models" GSoC project made great progress this summer; VTK now has Bézier patch interpolation and inversion for both prismatic and simplicial domains with parametric dimension 1, 2, and 3. The embedding dimension (the dimension of the control point coordinates) can be any dimension, so that simulations can interpolate vector- and tensor-valued fields to curve, surface, and volume splines. Furthermore, a high-level adaptor class was added to iterate over NURBS and tessellate each patch in the knot vector. This approach allows many different iso-geometric finite-element formulations to use the same functionality for visualization even though their basis functions are different.

Figure: control points for a test patch (left) and a NURBS model visualized in VTK (right)

Eulerian Motion Magnification

by Ashray Malhotra with David DeMarle and Andrew Bauer

https://github.com/ashray/VTKCodes/tree/master/ImagePyramid

I implemented a technique called Eulerian Motion Magnification. This technique involves magnifying minute motions in videos to be able to see them with the naked eye. The basic idea of the project is to magnify adjacent frame differences. The crux of the project is to “smartly” get those differences so as to not magnify noise along with the signal, and how to magnify motions that lie in a certain frequency range.

The code has three main components. One is a YIQ color space converter that was merged into VTK early on in the project. The second is an image pyramid class that we use to store and work with with images in a multiresolution framework. The last is an overall driver application that reads in and operates on image sequences to produce an augmented result sequence.

Figure: input (top)  and motion accentuated (bottom) images

External Faces in VTK-m

by Brent Lessley with Robert Maynard

git@gitlab.kitware.com:vtk/vtk-m.git

As part of my Google Summer of Code project I worked on VTK-m project to implement parallel versions of two important algorithms in the high-performance data visualization community – External Faces and Gaussian Splatter. I contributed worklets for both to the open-source library. The External Faces implementation that I contributed is also used in a paper I wrote looking at the performance of different External Faces implementation on GPUs.

Description: Macintosh HD:Users:demarle:Desktop:Screen Shot 2015-11-06 at 5.46.45 PM.png

Figure : Example use case application of a splatter technique. The sample points from the sculpture face are splat onto an output grid that is rendered as a volume using an isosurface algorithm.

Improvements to Earth and Space Science Visualization

by Jia Chen with Aashish Chaudhary

https://github.com/jiac5/SEGY_LOADER

RDV (short for real-time data viewer) format was first used by NEES to specify the seismic events, and later becomes a widely used file format for sharing seismic and microseismic events. We worked on creating a reader that can parse the data from RDV format into VTK.

SEG-Y is a standard developed by the Society of Exploration Geophysicists (SEG) for storing geophysical data. It is an open standard, and is controlled by the SEG Technical Standards Committee, which is a non-profit organization. The new VTK SEG-Y reader supports loading data from SEG-Y format. Depending on the parameters, it can return a vtkImageData (for 3D SEG-Y files) or a vtkPolyData (for 2D SEG-Y files) structure. Also, developed new Slice Widget to visualize seismic dataset in VTK (Left image is generated in VTK and we have compared it with an image in OpenInventor).

Figure: Visualization of 2D SEG-Y file

Shared Memory Parallelism in VTK

by Vincent Chen with Berk Geveci and David Gobbi

https://gitlab.kitware.com/vtk/vtk/merge_requests/551

The goal of this project was enhance the SMP (symmetric multi-processing) functionality of the VTK image filter pipeline, by utilizing the vtkSMPTools within the vtkThreadedImageAlgorithm base class and certain other classes. The results were encouraging, out of the five benchmarked filters four saw a performance improvement of 20 to 30 percent on a 36 core Xeon test machine. In addition, the implementation of the SMP framework has been enhanced to provide flexibility in tuning the different SMP parallelization parameters to optimize for particular use cases.

Figure: Performance boost to 5 image filters from new SMP framework.

VTK Parallel Partitioning Project

by Abishek Kumar with John Biddiscombe

https://github.com/abhishek4747/pv-zoltan/tree/gsoc-abhishek4747/

The core of the project was to partition the data in parallel and identify characteristics of data by communication and data exchanges among these parallel processes. If data is large then these processes could potentially be run on different nodes of a cluster. John had already built an extension of paraview to partition the data* using Zoltan library and find ghost regions* from the point data.

The first task that we accomplished was to replace Zoltan library with its successor, Zoltan2, which has significantly different interface and supposedly better optimizations. Zoltan2 is not yet fully implemented, so we ran into some problems and are still using few parts of Zoltan library. Benchmarking of the new partitioner still needs to be done.

The second task that we accomplished was to identify ghost regions. We investigated doing so via three algorithms during this project.

With boundry cells on both processes..png

Figure: the boundary regions, which we identified earlier, are now being copied to all the regions they belong to (which wasn’t being done earlier). The colored strips shown in this figure are found using neighbor touching algorithm, which are irrelevant to us.

Conclusion

Our students had a very productive summer, and added a number of new features to VTK. They went beyond developing in isolation for class projects to implementing and integrating features into a codebase with years of history spanning multiple disciplines and domains.

We hope our students enjoyed their summers. One said:

  • “Both the challenging and rewarding part was how to write good, "reusable" code which was never a concern in any of the projects I had done before since people only cared about the result of the execution of the code, not how well the code was written.“

Another said:

  • “While contributing new algorithms for the project, I constantly had to formulate multiple, creative design patterns/ideas for parallel computations that were not directly supported by a library function (e.g., a Scatter operation). This definitely enhanced my algorithm design and programming skills.”

Others said: “GSOC has been an awesome learning experience” and simply “Prepare early, communicate often and work hard :-)”

Questions or comments are always welcome!