Google of Summer of Code midterm results

The students in VTK's Google summer of code program are well on their way to being transformed into polished open source developers. With the help of their mentors all six of the students selected in the highly competative proposal process have passed their midterm evaluations. There are a little bit less than two weeks left in the program now and we have high hopes that all six will deliver something useful to the rest of the open source community. This following is a sampling of what they had accomplished as of the midterms:


 

VTK Parallel Partitioning Project 

by Abishek Kumar with John Biddiscombe

 

I started my work on 25th May and John provided me access to a supercomputer for development. But I faced few setbacks at the start because setting up environment, development and building on the cray machine was too painful for me. So I switched to my laptop for development and managed to do the partitioning of points using Zoltan2 by mid-term. We plan to use this cray machine for benchmarking and testing towards the end of the project.

Later also, we ran into some problems, the RCB (recursive coordinate bisection) algorithm which we were planning to use for our partitioning is not fully implemented in the Zoltan2 library yet. It doesn't have bounding box support. So we fell back on the ‘Multi Jagged’ algorithm (MJ) and continued the development (the MJ algorithm can be made to emulate the RCB algorithm by setting the split planes parameter appropriately). Till now I have managed to get both ParticlePartitionFilter and MeshPartitionFilter running. We have also added a weighted partitioning feature i.e. we can assign a weight to every point and then partitioning will be done according to sum of weights of points rather than number of points, this is important for load balancing when a ‘cost function’ must be taken into consideration. Things left in my project are to use a better algorithm for finding ghost cells and do sub-partitioning i.e. if a node has multiple cores then further partition the data using multiple cores. 


Eulerian Motion Magnification

by Ashray Malhotra with David DeMarle and Andrew Bauer

 

This technique involves magnifying minute motions in videos to be able to see them with naked eyes. The basic idea of the project is to magnify adjacent frame differences. The entire project is to “smartly” take those differences to reduce noise etc. We try out variety of temporal and spatial filters to be able to magnify motion from different types of videos. 

The workflow of the algorithm is as follows –

  • We consider each of the frame independently.

  • We convert each frame from RGB to YIQ/NTSC image domain.

  • We creata an image pyramid of each of the color channel independently.

  • We perform some temporal filtering(like IIR, butterworts etc) on the input frames

  • We magnify the difference that we get from the temporal filtering using spiral filtering techniques

  • We do some chromatic aberration of each of the color channel to reduce the noise components

  • We add the magnified difference back to the original image and convert the image back to RGB. This gives us the frame of the output video with magnified motion.

This technique was first presented in the paper which can be found at this website

http://people.csail.mit.edu/mrub/vidmag/

My major effort has been to implement EVM as a separate file using VTK and then later integrate it into the pipeline. The independent code for EVM can be found at the link below

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

 


 

External Faces in VTK-m

by Brent Lessley with Robert Maynard 

 

As part of the GSoC, I am working with Robert Maynard to develop parallel implementations of scientific visualization algorithms, using the VTK-m open-source toolkit maintained by Kitware.  Currently, I am contributing a filter that extracts the external, non-overlapping faces from a mesh of tetrahedral cells; see accompanying figures.  The performance of this algorithm is being assessed on different input mesh sizes with both CPU and GPU execution.  During the second half of my GSoC experience, I intend to refine the external faces filter and design a parallel solution for another important visualization filter, such as the Gaussian Splatter procedure.


 

Shared Memory Parallelism in VTK

by Vincent Chen with Berk Geveci and David Gobbi

 

The project aims to replace the original multi-threader with the new SMP interface.  Doing so will result in more efficient utilization of multi-core systems for imaging filter loads.  SMP accomplishes this through user-specified splitting parameters as well as the work-stealing paradigm of SMP’s backend.  SMP handles the process of calculating correct split indexes while still giving users the flexibility to choose the granularity of the split, as well as specify an ideal split shape, in order to optimize for performance.  In our initial testing, we have found that SMP scales quite effectively for processor-intensive filters.

 

 

CAD Model and Simulation Spline Visualization

 

by Lin M with David Thompson

 

So far, I have added quite a few new funtionalities to the vtkFiltersBezier module, including

  • evaluation for 1-d, 2-d and 3-d bezier patch

  • generate line segments and triangle meshes to visualize bezier curves and surfaces

  • an adaptor to convert NURBS to bezier patch

So in summary, we have implemented the functionalities to visualize NURBS patch in VTK lib.

 

 

 

Improvements to Earth and Space Science Visualization

by Jia Chen with Aashish Chaudhary

 
Stay tuned for details in our next blog …
 

 

We wish all of the students the best of luck on the final push toward project completion. We would like to thank the mentors for their efforts and especially Google for putting on on such an great program! 

Questions or comments are always welcome!