SOFTWARE DEVELOPER’S QUARTERLY Issue 13• April 2010
ParaView 3.8 Editor’s Note...... 1 Kitware, Sandia National Laboratories and Los Alamos National Laboratory are proud to announce the release of Recent Releases ...... 1 ParaView 3.8. The binaries and sources are available for download from the ParaView website. This release includes Visual Debugging of ITK ...... 3 several performance improvements, bug fixes for users, and plenty of new features for plugin and application develop- The CMaking of a Humanoid ...... 7 ers. We have made it easier to locate cells/points in your dataset using queries. Search the ParaView Wiki for "Find Paraview in Aerodynamics...... 9 Data using Queries" for more information. The plugin loading and management dialog was redesigned Kitware on Apple OS X: It Just Works, in MacPorts ...... 11 to make it easier to load plugins. It's now possible to config- ure plugins to be auto-loaded every time ParaView starts. MRCAD for Daily Clinical Analysis of Prostate MR ...... 14 We've added support for plotting over curves and intersec- tion lines using the filters "Plot On Sorted Lines" and "Plot On Intersection Curves". MATLAB® and GNU R Integration with VTK...... 16 A couple of GPU-based rendering/visualization techniques In Progress...... 17 have been incorporated along with GPU-based volume rendering support for 3D image volumes, which is accessible Kitware News ...... 18 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.
The Kitware Source contains articles related to the develop- ment of Kitware projects in addition to a myriad of software updates, news and other content relevant to the open source community. In this issue, Matt McCormick provides a tutorial for using Python pretty-printers to debug ITK. Giorgio Metta, Paul Fitzpatrick and Lorenzo Natale explain how the use of CMake improved their development of a humanoid robot. Jean Favre and Jan Vos show how the Navier Stokes Multi Block solver plugin for ParaView supports a wide range of data analysis tasks. Darren Webber provides a tutorial for VTK and ITK MacPorts to get Kitware tools up and running on Darwin-OSX systems. Henjkan Huisman and Pieter Vos share their experience using VTK, ITK and IncrTCL to achieve a robust, versatile, clinical research platform for prostate MR. And Tom Otahal provides a follow-up article along with the locations of integration classes for his October 2009 article on the integration of MATLAB and GNU R with VTK. The Source is part of a suite of products and services offered to assist developers in getting the most out of our open source tools. Project websites include links to free resources such ParaView now includes (in source form only) an interface as: mailing lists, documentation, FAQs and Wikis. Kitware to the University of Utah's Manta interactive software ray supports its open source projects with textbooks, consulting tracing engine. The Manta plugin provides a new 3D View services, support contracts and training courses. For more type which uses Manta instead of OpenGL for rendering. The information, please visit our website at www.kitware.com. plugin is primarily being developed for visualization of large datasets on parallel machines. In single processor configura- For developers, this release includes major changes to the tion it has the benefit of allowing realistic rendering effects core ParaView libraries making it easier to create and deploy such as shadows, translucency and reflection. custom applications based on the ParaView framework. This enables developers to create applications with funda- mentally 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 develop- ers to build and distribute plugins that are compatible with the binaries downloaded from our website. 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. In terms of performance improvements, we've greatly improved the first render time for datasets with large CMake 2.8.1 numbers of blocks. Raw image reading for parallel file We are happy to announce the release of CMake 2.8.1. This systems underwent a major overhaul making it fast and effi- is a minor release from 2.8.0. In addition to addressing many cient. Options were added to the Settings dialog to fine tune issues, this version of CMake adds some new features as well. image compression, improving interactivity when remote The parallel nmake replacement from Nokia jom, now has its rendering over connections with varying bandwidths. own tested generator in CMake. After the introducing Python tracing in the previous release, CTest can correctly kill process trees when a timeout occurs. we have expanded the purview of tracing to include selec- The ctest_* commands have been enhanced to take more tions, lookup tables, and implicit functions. options. When using the Intel compilers CMake can correctly For climate simulation folks, this release includes support determine 32 bit vs. 64 bit builds. When running in parallel for NetCDF with CF (Climate and Forecast) conventions. For mode (-j N), CTest can now compute and use a cost value for cosmology researchers, the Cosmo plugin has been substan- each test to ensure the tests are run in an optimal order. tially revised. The major improvement is that the plugin now works in a data parallel fashion, so that it can be used with VTK 5.6 higher resolution simulation results. We have reintroduced Kitware is planning to release VTK 5.6 this spring. Since the basic support for CAVE rendering which was lost since the previous release, 270 new C++ classes have been added. The major overhaul for ParaView 3.0. new features in VTK include improved support for line charts and bar charts that don't depend on Qt. With this release AdaptiveParaView, a new experimental application devel- VTK provides a new text analysis module. Another major oped using the ParaView application framework is also improvement is support for parallel rendering. now available in source format. Like StreamingParaView, AdaptiveParaView processes structured datasets in a piece- This release also includes changes that improve performance. wise fashion, omitting pieces which are unimportant, in VTK can now locate and insert non-uniformly distributed order to make it possible to visualize datasets which do not points three times faster than the previous version. otherwise fit in RAM. AdaptiveParaView differs from prior We've improved GPU support in VTK. The vtkGPUVolumeR- work in that it renders pieces in a multi-resolution manner, ayCastMapper has been migrated from VTKEdge to VTK. VTK initially producing low-resolution images and then progres- 5.6 contains a GPU-based real time Line Integral Convolution sively filling in greater detail within the viewing frustum. (LIC) with enhanced image contrast and LIC + geometry com- This application still contains many experimental features positing for dense vector field / flow visualization. These are and is not yet documented, but we encourage users to try it just the highlights. For a complete list of changes, visit the out and report bugs and feature requests. VTK Wiki and search "VTK 5.6 Release Planning." PVBlot is a command tool for batch or interactive processing ITK 3.18 of Exodus data files. It is provided as a plugin. The commands ITK 3.18 will be released in the early spring. The main changes create various mesh visualzations and XY plots of variable in this release include: versus time, or variable versus variable. The plugin adds an interactive pvblot console to the ParaView Tools menu. • Improvements in implementation of mathematical traits, Documentation for PVBlot is built into the tool, just type particularly for fast rounding, contributed by Brad 'help' or 'help
2 • Recently added classes were included in the Wrapping, thanks to Gaetan Lehmann. • Improved support for Symmetric Tensor operations, thanks Visual Debugging of ITK to Luke Bloy. • Improved behavior of the Object Factories, thanks to Brad Lowenkamp. It is well known that a good debugger is an essential pro- • Improved testing for Discrete Gaussian derivative filter, gramming tool. Debuggers serve not only to effectively thanks to Ivan Macia. resolve defects, but they provide a means to examine the mechanics of an unknown code base and enable rapid devel- Thanks to Michel Audette, BSplineDeformableTransform opment of new code. now clones its bulk transform in the multi-threaded image registration metrics. Bill Lorensen's work on GDCMImageIO Until recently, debuggers had limited utility for complex, computation of proper orientation and origin has enhab- high-level libraries like ITK. The built-in print capability of ced MR Image Storage for DICOM images. Mattes Mutual debuggers was limited to simple, low-level data types such as Information metric now works on binary images. Thanks to float, char* or C arrays. Examining complex C++ classes, such Serena Fabri and Hans Johnson for reporting this bug. Brad as an itk::Image, in an informative manner was difficult. Lowenkamp and Kent Williams fixed support for analyzing However, the PythonGDB project [1] has solved this problem images of large size. The behavior of the VTKPolyDataReader by allowing the creation of custom pretty-printers for arbi- was fixed by Bill Lorensen. trary data types. GDB [2] now has support for an embedded Affine registration of 3D images with Mean Squares Python interpreter that hooks into much of the debugger’s metrics, affine registration of 2D binary images using functionality. In this article we describe how to use custom MatchCardinalityMetric and AmoebaOptimizer, and compu- Python pretty-printers to improve development of ITK code. tation of bounding boxes for segmented images were added in Insight. Extraction of iso-surfaces from segmented images An example and generation of screenshots from iso-surfaces were added Note: The code for this example can be found in the examples in Insight Applications. subdirectory of the author’s ITK pretty-printer repository, gdb-pretty-itk [3]. The following papers from the Insight Journal were moved into the Code/Review directory: Custom text printer Run GDB on the executable that has been built with debug- • "Go-Go Gabor Gadgetry" by Nick Tustison and James Gee, ging symbols: Penn Image Computing and Science Laboratory University of Pennsylvania. (http://hdl.handle.net/1926/500) gdb ./itk-example
Set a break point after we have called Update() on an itk::ImageFileReader object:
(gdb) break 33 Breakpoint 1 at 0x41df69: file /tmp/gdb-pretty/ ... (gdb) run lena.bmp heart.mhd [Thread debugging using libthread_db enabled] Breakpoint 1, main (argc=3, argv=0x7fffffffd518 ... 33 reader2D->Print( std::cout );
ITK has written into the code Print() methods for almost all (a) (b) objects. This is intended to provide debugging information (a) 2-D Gabor image and (b) a 2-D slice from the 3-D Gabor image. about the object’s state. We evaluate the next line of code to see the output of reader2D‘s Print() method: • "A Label Geometry Image Filter for Multiple Object Measurement" by Dirk Padfield and James Miller, GE (gdb) next Global Research. (http://hdl.handle.net/1926/1493) ImageFileReader (0x7257f0) RTTI typeinfo: itk::ImageFileReader
3 (gdb) print reader2D $1 = "itk::ImageFileReader (0x7257f0)" = { RTTI typeinfo = itk::ImageFileReader
Notice that in this case it is no longer necessary to have PrintSelf() methods embedded in the library’s code. We also do not need to write in the debugging statement, re- compile, re-run, and then remove the debugging statement every time we want to investigate internal behavior. We can try this on the itk::Image object:
(gdb) next The next part of the code talks about doing some kind of 41 Reader3DType::Pointer reader3D = beautification. What does it really do? Reader3DType::New(); (gdb) print itkImage2D $2 = "itk::Image (0x729bd0)" = { (gdb) list 38 RTTI typeinfo = itk::Image
2D Image printer The GDB Python interface has other simple, effective, and powerful capabilities in addition to creating custom pretty- printers. For example, custom commands can be created. These commands can be loaded using 'require'. Let us load a command that allows selection of a specific pretty-printer (assuming many are available for printing the same data type):
(gdb) require command view ' The ‘view with’ command takes two arguments: a regular expression that specifies the module that the desired pretty- printer lookup_function is defined in (explained later), and an expression to be passed to the print command. Available modules are shown in itk-example-gdb.py. We issue:
(gdb) view with matplotlib.imshow itkImage2D
And we immediately see the contents of the image’s BufferedRegion. We see it added a beauty mark above her lip.
4 3D Image printer Custom, visual pretty-printers can be generated for 3D (gdb) view with mayavi.ipython itkImage3D $7 = /tmp/tmpfbKd8u/7.vtk /tmp/tmpfbKd8u/7.npz mlab images too. For example, iso-contours can be viewed using pid = 14823 Mayavi [4]:
(gdb) b 63 Breakpoint 3 at 0x41e473: file /tmp/gdb-pretty/ ... (gdb) c Breakpoint 3, main (argc=3, argv=0x7fffffffd518 ... 63 return EXIT_SUCCESS; (gdb) view with mayavi.contour itkImage3D
This loads an IPython shell with variables in the local namespace corresponding to the printed value.
In [1]: val7 Out[1]:
Or we can interrogate the data with an application such as ParaView or VV [5]:
(gdb) view with vv itkImage3D
Subregions of the image can be easily extracted and examined.
In [3]: arz4 Out[3]:
In [4]: arz4.items() Out[4]: [(’scalars’, array([[[16, 15, 16, ..., 24, 26, 30], [18, 13, 15, ..., 24, 27, 31], [15, 10, 11, ..., 20, 26, 31], ..., [44, 45, 39, ..., 39, 36, 28], [ 0, 0, 0, ..., 0, 0, 0], [ 0, 0, 0, ..., 0, 0, 0]], [...] [58, 59, 47, ..., 43, 41, 35], [62, 57, 43, ..., 38, 33, 26], [55, 54, 49, ..., 34, 26, 18]]], dtype=uint8)), (’origin’, array([ 0., 0., 0.])), (’spacing’, array([ 1., 1., 4.]))]
In [5]: plt.plot( arz4[’scalars’][:,10,10] ) Examining in an interactive IPython shell We can dynamically explore the data in an IPython [6] shell We can also save images as we progress through our program using Matplotlib’s 2D pyplot facilities [7] or Mayavi’s 3D Mlab for comparison by subtraction or other exploratory methods facilities: in our IPython session.
5 A lookup function can be any Python function that per- forms filtering on the value. In practice, the lookup function usually consists of a few common steps focusing on the type attribute associated with the gdb.Value. If the type is a reference, it is converted to the type that it references. If the type is a typedef, it is converted to the original type. Filtering can examine template arguments. If the type is an itk::SmartPointer<>, the template argument is extracted. Finally, a pretty-printer Python dictionary associates a regular expression matching the typename to the corresponding pretty-printer class.
Step 3: Associate the lookup function with an object file Lookup functions can be associated with GDB objfiles. Here objfiles refer to executables or libraries. A file in the same directory as the executable or library with the same name except for an appended -gdb.py gets executed when GDB loads the objfile. This script is used to register the lookup functions associated with the program or library. This allows only the pretty-printers needed by the program to be loaded, How it works which reduces startup time. The order of the lookup func- Step 1: Define a class’s pretty-printer tions also determines the default pretty-printer. A custom pretty-printer is a Python class that follows a simple API. For example, the complete itk::Object text printer is: Further reading The author’s GDB branch used for this article can be found on gitorious [8]. ITK pretty-printers can be found at the same from itk.v3.text.Common.LightObject import \ ITKLightObjectTextPrinter location, gdb-pretty-itk. Documentation for GDB and the Python API can be generated by calling ‘make html’ in the NOT_A_TEMPLATE = True gdb/doc directory of GDB’s source. A screencast demonstrat- class ITKObjectTextPrinter: ing custom pretty printers can be found at archive.org [9]. def __init__ (self, val): self.val = val References lop = ITKLightObjectTextPrinter (val) [1] Work to integrate Python scripting into GDB http://source- self.parameters = lop.parameters + \ ware.org/gdb/wiki/PythonGdb/ [ ("Modified Time ", val['m_MTime']), [2] The GNU Debugger. http://sources.redhat.com/gdb/ ("Debug", "On" if val['m_Debug'] else "Off"), ("Observers", \ [3] http://gitorious.org/gdb-pretty/gdb-pretty-itk/ val['m_SubjectImplementation']['m_Observers'] \ [4] VTK based scientific data visualizer http://code.enthought. if val['m_SubjectImplementation'] \ com/projects/mayavi/ else 'none') ] [5] VV is an open-source and cross-platform image viewer, designed for fast and simple spatio-temporal images visual- def to_string (self): ization: 2D, 2D+t, 3D and 3D+t (or 4D) images http://www. return "itk::Object (" + \ str (self.val.address) + ")" creatis.insa-lyon.fr/rio/vv/ [6] An advanced interactive shell for Python. http://ipython. def children (self): scipy.org/ return self.parameters [7] Pure Python plotting library with MATLAB like syntax. http://matplotlib.sourceforge.net/ def display_hint (self): return 'string' [8] http://gitorious.org/~thewtex/gdb-python/archer-thewtex- python/commits/archer-thewtex-python-next The class’s constructor takes a Python gdb.Value object as an [9] http://www.archive.org/details/ argument. A to_string() method defines how to generate a VisualDebuggingWithCustomPrettyPrinters string representation of the object. An optional children() method returns an object that follows the Python iterator Acknowledgements: protocol, in this case a Python list, which returns a (‘name’, Thanks to Tom Tromey, Jan Kratochvil, Joel Brobecker, Phil value) tuple child on each iteration. The display_hint() is an Muldoon, et al. for their work on the GDB project and help- optional method used by the user interface during display fulness on the mailing lists and IRC. of the output. Matt McCormick is a PhD candidate at the Step 2: Create a lookup function University of Wisconsin-Madison in the When the print command is executed in GDB, the result- Department of Biomedical Engineering. His ing value is passed to the registered pretty-printer lookup research interests include diagnostic ultra- functions. The lookup function should return either a pretty- sound strain imaging and parametric tissue printer class that can print the value, or the Python object characterization. He enjoys scientific com- None. If the lookup function returns None, GDB passes the puting and is an active member of value to the next registered lookup function. If no custom UW-Madison Hacker Within (hackerwithin.org). pretty printer is found to print the value, the default print behavior is executed.
6 developed by Linux users, and vice versa. Most of the time, developers could now forget about any development envi- The CMaking of a Humanoid ronment other than their own, and our community became a lot less "balkanized". In the RobotCub project [1], we've been building a human- CMake helps individual developers oid robot called the iCub. There are about a dozen iCubs in Although we did not anticipate this, we discovered that existence today (see Figure 1). The iCub design is free and CMake saved individual developers a huge amount of time, open source. The designs for the mechanical and electrical even before their work was used by others. One of our components of the robot, its bill of materials, and all of its developers said "I can't imagine how much time I spent in software are released publicly under free and open source my life cloning Visual Studio project files". CMake proved licenses [2,3]. The iCub was created as part of a European to be a better way of managing projects than was possible project which began in September 2004 and ended in January within MSVC itself. Similarly, beginner Linux users were very 2010. There are several follow-on projects using and extend- happy to stop looking at Makefiles that they didn't really ing the robot in many ways, and we hope it will be a catalyst understand and had a hard time modifying. CMake democ- for research in robotics, embodied cognition, experimental ratized the build process through simplification. psychology, and perhaps fields we've never even heard of. There were a lot of challenges in building the robot and Another unanticipated benefit was noticed over time. For making it usable. On the software side, CMake has been very MSVC users, as new compiler versions were released (VC8, important to us. We'd like to say a big "thank-you!" to the VC9, VC10), they were saved from dealing with a lot of CMake developers, and explain a little about how CMake problems because their projects were already described in a helped us along the way. compiler-neutral way, and CMake was prompt in its support for those compilers. Linux users found they could easily experiment with alternative development environments such as KDevelop or Eclipse. It was great for the RobotCub project not to have to dictate or even care about the devel- opment environment our developers worked with. Since 2007, there's been a big movement from Windows toward Linux amongst students, principally driven by the phenomenal growth of Ubuntu. At our 2006 summer school, Windows was dominant; by 2009, the numbers were com- pletely reversed. However, people whose background lies Figure 1: The iCub is a full humanoid with legs, dexterous hands, outside of computer science seem more likely to be still using and a simple expressive face. The iCub is the size of a young child. Windows. Today, some robotic software projects neglect support for Windows (typical quote: "let's be serious: it's a Making a humanoid robot is a huge task, requiring both robotic tool!"). Since humanoid robotics is a very interdisci- novel research and patient integration work. It is practically plinary field, we believe it would be a mistake for us to adopt impossible for any one person to be an expert in everything that attitude. In any case, good Windows support, via CMake, involved. Typical members of our development team are has actually helped individuals working on RobotCub make graduate students and postdocs who are experts in their the leap from Windows to Linux, since they know they'll be fields, but may not necessarily be accustomed to working able to compile their code from day one. In general, CMake with others on software development. CMake turned out to reduces lock-in to any particular development environment, be a wonderful tool for us, for the following reasons. which feels very liberating. CMake helps developers work together CMake helps summer schools succeed People with all sorts of backgrounds end up working Since 2006, the RobotCub project has had an annual summer in humanoid robotics, so we see a lot of diversity in the school ("VVV 06-09", and the school will continue in 2010 development environments which people are comfort- under the auspices of the ITALK project). The schools are able. The biggest divide, when we began, was between essentially hackathons where we take whatever hardware users of Microsoft Visual Studio on Windows, and users of we have to a nice locale in Italy and invite anybody with the gcc+make+emacs/vi/... on Linux. From the start, RobotCub necessary skills to come play. The schools are BYOL (Bring committed to formally supporting both these groups. But Your Own Laptop), and have proven to be an excellent it was a lot of tedious work to keep all of the build files "forcing function" for making the iCub usable and inte- synchronized, even with some custom scripting to help. And grated. From the start, CMake has been a big help in getting it was difficult to force individual developers to spend time such a mob of programmers up and running and collaborat- dealing with tedious details of environments they didn't use ing. Here's how we introduced CMake at the first summer or care about. This was a recipe for long unproductive dis- school, VVV06 (see Figure 2): cussions about why everyone should be using the one true development environment (whichever that was). "We'd like you all to use the development environment you are used to, and not force you to switch to some- The first CMakeLists.txt file entered one of our repositories thing else -- no Linux/g++/emacs vs Windows/DevStudio in April 2006 with the commit message "CMake, for easier vs Mac/... fights please! To achieve this without complete Windows distribution" (this was clearly the perspective of chaos, we ask you to install "CMake". CMake lets us a Linux developer tired of dealing with Windows). After describe our programs and libraries in a cross-platform some experimentation, doubts, and dabbling with alterna- way. CMake takes care of creating the makefiles or tives, it became clear that CMake was a huge win. It gave a workspaces needed by whatever development environ- first-class experience to MSVC users when compiling projects ment you like to work in."
7 We suspect that the open attitude that CMake facilitates has to "feel free to place new modules in [the repository] that played no small role in the success of the school. aren't yet well tested, are currently broken, came to you in a deranged dream, etc." We found that it was very important to keep the initial barrier to entry very low, or code tended to stay hidden within institutions until it was fully done and perfect (i.e. never). With a low barrier to entry, there was mutual visibility between developers in the different insti- tutions, and collaboration was easier to get going at the programmer level. Once developers are sure their module is no longer a "deranged dream" and, more specifically, are confident that it compiles on machines other than their own, they are encouraged to add it to the global build for the repository. This is quite a simple process even for inexperi- enced users: in most cases it is enough to customize a simple template CMakeLists.txt file and include it in the main build. Once in the global build, the module is tested automatically on our "officially supported" Linux/gcc and Windows/MSVC Figure 2: how we presented CMake to students in a presentation. version combinations and we do some quality control at that point. CMake helped us scale up our repository The plot below illustrates how the RobotCub software reposi- RobotCub's community of developers is open and dispersed. tory has grown during the project from its establishment in The member institutes of the formal RobotCub consortium 2006, to the end of the project. At the end of the project our are scattered throughout Europe and we have collaborators community consists of 32 developers (all contributing code worldwide. Software development mostly happens within an in the past year), with almost 1 million lines of code and academic environment, where project and thesis schedules about 120 modules (programs and libraries) compiled in a may conflict and the backgrounds or skill-level of developers single project (see Figure 3): vary widely. The most interesting software is often novel, experimental, created by researchers whose main skills (nat- urally and rightfully) lie in their problem domain rather than 120 modules applications in software engineering. Due to paper submission deadlines, this software is often written in a hurry with little thought to 100 reuse by others. For all these reasons, building up a common software repository for the iCub robot has been an interest- 80 ing experience.
With a large community of loosely-coordinated developers 60 it was difficult to reduce the list of dependencies required to compile the whole repository. In addition, some of the low-level code was not fully redistributable and thus, could 40 not be included in the repository (this was the case for some device drivers required to interface with the hardware). 20 Quite soon, being able to compile every single module in the repository required a large list of dependencies. This is some- 0 thing that often scares users away, especially in Windows, 2004 2005 2006 2007 2008 2009 where package management is not as evolved and helpful Figure 3: growth of the RobotCub repository. The nomenclature we as in other operating systems. For understandable reasons, use is a little non-standard. A "module" is any program or library, new users are not very eager to spend a long time setting up and an "application" is a logical collection of intercommunicating software. CMake turned out to be very helpful in this. Our programs that performs a specific robot function (such as gazing, repository has a modular structure, where a group of flags grasping, or crawling). The graph counts the modules that were govern the activation of groups of modules (e.g., graphi- compiled in the main project. In 2006, the repository was estab- cal user interfaces, low-level modules providing hardware lished with a few modules. By 2008, there were 50 modules and 5 support, the simulator and so forth). Users that do not have applications. In 2009, there were 120 modules and 15 applications. all the required libraries can still compile a subset of the code, and start playing with it. Our policy is that the build process should not raise fatal errors when dependencies are Conclusions not met, but rather should make available only the group of CMake helped keep our developers from being divided by modules that can be compiled with the available dependen- operating system, and no one was given the impression cies. These flags controlling the build are made clear in the that they were a second-class citizen. Everyone spent more CMake GUI so that the user is aware that some parts of the time working and less time fiddling around. Our repository build are not available. Getting and building the repository grew to the scale we needed to operate a multi-functioned is an incremental and friendly process that avoids scaring humanoid robot, without trouble. New users were able to away (new) users with incomprehensible error messages build the parts of the project they were curious about first, about unmet (and sometimes unwanted) dependencies. and work their way up to everything else as they needed to. Being relatively early adopters of CMake, we made a bit of For contributing to the repository, we have kept a low barrier a muddle of our build structure (we had never used CMake of entry. RobotCub folks are told, in the top-level README, before RobotCub), but things worked out remarkably well
8 in spite of that. More recently, we've noticed many peer military aircraft to hypersonic flows including air chemistry projects starting to use CMake, for example Player/Stage and over future re-entry vehicles. ROS. It is good to see this "bottom-up" convergence, since it The NSMB solver solves the Navier Stokes equations using makes collaboration easier. the finite volume approach. Space discretization schemes It is striking how many free and open source projects played include central and upwind methods. The equations are a vital role in developing the iCub: CMake, Doxygen (which integrated in time using the LU-SGS scheme. allowed us to easily pool and browse documentation, and NSMB offers a variety of modern turbulence models. Different provided "soft" pressure on developers to actually write that levels of chemistry modeling are available for hypersonic documentation by making its absence very obvious), SWIG flows, ranging from chemical equilibrium to thermal chemi- (was very useful in expanding our pool of users), the OpenCV cal non-equilibrium. NSMB has been parallelized using the library (which served as a de facto standard for basic com- SPMD paradigm using MPI as message passing. puter vision algorithms, rather than everyone writing their own). The list goes on and on. We hope that the iCub robot ParaView has been an important asset to this small com- or a descendent will find a similarly useful role in robotics, pany's portfolio of tools, and is used in mesh and fluid flow and are grateful to our funder, the European Commission, visualization tasks. for allowing us to give back to the free software community The NSMB solver archives its data in a proprietary file format. that has served us so well. Large and complex flight geometries can produce gigabytes References of data for steady and transient simulations. [1] RobotCub project website, http://www.robotcub.org Our interface has grown alongside the release cycles of [2] RobotCub hardware designs, http://eris.liralab.it/wiki/ ParaView, and we are today, extremely grateful to Kitware RobotCub and the open source community at large for all the features [3] Aggregrated RobotCub software, http://eris.liralab.it/brain/ available. Our ParaView plugin for the NSMB solver supports a wide range of data analysis tasks, which we succinctly Paul Fitzpatrick received his MEng in com- present here. puter engineering from the University of Limerick, Ireland, and his PhD in computer Hierarchical Meshes, quantitative and science from MIT for work addressing qualitative displays developmental approaches to machine Our reader plugin relies on a low-level access API for the coor- perception, implemented on the humanoid dinates and data arrays, and lets us concentrate on building robots Cog and Kismet. the VTK objects used by a hierarchy of multiple containers of 3D and 2D grids. Enabling parallel reading was particularly Giorgio Metta is senior scientist at the IIT important, given today's multi-core servers and desktops. In and assistant professor at the University of fact, our rendering needs are often easily handled by a single Genoa where he teaches courses on anthro- hardware renderer (the ParaView client), whereas a pvserver pomorphic robotics and intelligent systems can share the work load amongst several machines. for the bioengineering curricula. He holds a MS with honors and PhD in electronic engi- neering from the University of Genoa. His research interests include biologically motivated and human- oid robotics, in particular lifelong artificial systems which demonstrate the abilities of natural systems.
Lorenzo Natale is Team Leader in the Robotics Brain and Cognitive Sciences Department at the Italian Institute of Technology. Since 2000 he has been involved in various human- oid robotic projects, working on aspects related to perception, motor control and learning. He is also interested in software development and is one of the main developers of YARP, an open-source middleware for robotics. Figure 1: A collapsed view of our hierarchy of multi-block datasets.
A typical flight configuration may include several thousands of body-fitting 3D curvilinear grids, along with surface ParaView in Aerodynamics patches for the solid geometry, and the different bound- ary condition's walls. The data will include standard flow variables (density, pressure, velocity) and wall shear stress CFS Engineering is a consultancy company founded in vectors. ParaView enables the graceful presentation and August 1999, based in the business park at the Swiss sub-setting of such hierarchies of data blocks along with Federal Institute of Technology in Lausanne, Switzerland. data fields and multiple time-cycles. CFS Engineering offers services in the Numerical Simulation of Fluid Mechanics and Structural Mechanics Engineering Multi-parameter studies, where flow conditions may change Problems, and in particular, is active in the development of and the simulation is re-executed can take advantage of the the Navier Stokes Multi Block (NSMB) solver used in a variety side-by-side viewing available in Comparative View mode, as of aerospace problems ranging from flows over civil and shown below for a hypersonic flow simulation.
9 out.UnRegister(None) output.SetDataSet(iter, out) if in.GetFieldData().HasArray("BCcode"): code = in.GetFieldData(). GetArray("BCcode").GetTuple1(0) if code in [300, 305]: # this is the list of codes out.ShallowCopy(curInput) iter.GoToNextItem()
ParaView's trace tool enables rapid-prototyping, fine tuning, and execution with pvbatch, the parallel server of ParaView. Visualization campaigns that would last several days, and were driven from state files after some cumbersome and Figure 2: Transonic Cruiser Configuration from EU funded project error-prone hand-editing, can now be replaced by Python SimSAC at different angles of attack scripts. The scripts are also our preferred method for regres- sion testing. The integrated view possibilities enabling 3D geometry viewing, spreadsheet displays of tabular data, XY plots, Examples of a few CFD-specific filters and synchronized selection (highlighted in purple below), The following Python script drives our drawing of wall- between different viewports are also particularly handy. bound shear stress lines of Figure 4.
# defines a list of patch indices for the tailwing tailwing = ExtractBlock(reader) tailwing.BlockIndices = list1 rep2 = Show(tailwing) merge1 = MergeBlocks(Input = tailwing) clean1 = CleantoGrid(Input=merge1) mask1 = MaskPoints(Input=clean1) mask1.OnRatio = 7 mask1.Random = 1 stream1 = StreamTracerWithCustomSource(Input=clean1, Source=mask1) stream1.Vectors = ['POINTS', 'TauW'] stream1.IntegrationDirection = 'BOTH' rep3 = Show(stream1)
Figure 3: Density profiles around a wing side-cut and tabular data Plot-over-sorted-lines, a recent addition to ParaView, allows on the nacelle. us to draw an XY plot of pressure contours across wing side- cuts (left Figure 3). This is a must-have for CFD studies. Parallel execution and Python scripting Scripting is the key to a great visualization tool, and is vastly Data queries improved if done with Python. ParaView 3.6.2 now integrates A new addition to ParaView is a query engine, enabling selec- a trace tool, assisting the user in generating human-readable tion of nodes or cells by field values. Finding, for example, Python scripts. We foresee that the use of state files will the low-pressure points downstream of a flying aircraft to eventually disappear thanks to this new feature. study wing-tip vortices is now a trivial task with a simple query: Select Points where Pressure is less than 121000. We rely on Python scripting to automate the more mundane tasks, or to add functionality not available in the GUI. The points are then used as seeds for streamlines and they The following example illustrates how we can operate on highlight quite well the downstream high vorticity region, FieldData (there are currently no filters enabling access to the as shown below: FieldData). Our multi-patch surface geometries are encoded with a single integer, telling us what the boundary condition type is (e.g. solid, symmetry, inflow/outflow walls) or what the solid object is (wheel, wing, nose, body, nacelle). Part selection requires access to this 1-tuple array called “BCcode” and stored in FieldData. A Python Programmable Filter is the perfect tool to traverse the hierarchy of structured grids, shallow-copying only those matching a user-selectable set of codes, stored in a Python list: input = self.GetInputDataObject(0, 0) output = self.GetOutputDataObject(0) if input.IsA("vtkMultiBlockDataSet"): output.CopyStructure(input) iter = input.NewIterator() Figure 4: Wing-tip vortices ending in a low-pressure zone. iter.UnRegister(None) iter.InitTraversal() New representation plugins, are of outstanding value, to while not iter.IsDoneWithTraversal(): enhance our visual experience. Take the new Line Integral in = iter.GetCurrentDataObject() out = in.NewInstance() Convolution plugin, integrated into ParaView 3.8, and compare the two pictures below which depicts the wall shear
10 stresses on a wing. Recent work by Zhanping Liu at Kitware on the stream-tracer filter had already improved our ability Kitware on Apple OS X: It Just to draw the shear stress lines (left of Figure 5). Yet, this remains a very difficult task to automate. Challenges include Works, in MacPorts! the difficulty to control the density of streamlines; problems with very thin geometries (upper and lower sides of a wing Getting Kitware tools up and running on a Darwin-OSX along edges) and Z-fighting of streamlines showing both system is not as easy as loading binaries from the Kitware sets of lines along the edges; streamlines which gradually severs. This is because there are binaries for CMake on OSX, "lift" above the wings, and thus are stopped. The LIC painter but none for VTK and ITK. If you’ve rolled your own Kitware resolves these issues immediately (right image), can be run toolkits on Linux, you would think building from the source across multi-grid surfaces, and offers real-time display where is the next step. At least this is what I did. tuning is unnecessary on today’s commodity graphics cards. After downloading the release bundles for CMake, VTK and ITK, configuring, compiling and installing CMake and then configuring, compiling and installing VTK and ITK, I found myself wondering.... Did I get shared libs? Where are the .so files? I went back to ccmake to check the configuration and build again. The configuration specified shared libs, but I got a bunch of .dylib files. What are they and how do I look into them? (So Google and ohhhh! We use otool, not ldd, on OSX.) I also wanted a lot of other options, including wrapping for Python, connectivity to databases, and threading. So, I Figure 5: Streamlines and LIC texture for the shear stresses on the started to collect several more downloads, including binaries tail wing of a supersonic jet. for Python, MySQL, and PostgreSQL. I had no idea where these binaries were installed. I was wondering - what are Future work frameworks? Did I really ask for that? Do I really want to link against a framework? What were those config options Multi-block containers in VTK do not hold neighboring again? attributes. Yet, our flow solver data includes block-to-block and abutting patch information, and we think that some After hopping on the email list to ask for help from the filters could potentially use this metadata to speed up gurus I ended up, several days later, with several documents spatial search tasks for example, in streamline computation. on how to configure a dozen packages, lots of mysterious Topology-based filters could also provide information such build and run-time dependencies, tons of email threads on as vortex cores, and critical point analysis beyond the quali- several lists, and I lost a couple of handfuls of hair! tative displays rendered by the LIC painter. Building these tools on Darwin-OSX is not so easy. I thought Our parallel strategy for grid placement on the different MPI to myself, there has to be a better way! I soon realized that ranks of the ParaView server currently uses a round-robin ports exist to provide access to some of the Kitware tools. assignment. Surfaces patches, which are special VOIs of the However, I also realized that they do not provide all the 3D blocks are also kept by the processor holding the grid. options that I want. And then I found MacPorts. After learn- Yet, ordering comes from the mesh partitioner and can vary ing a few things about how to use and develop ports, it was quite a bit, bringing together blocks which are far apart. We clear that MacPorts provides (a) a way to effectively docu- are currently working on optimizing this block-to-processor ment the build and install process, (b) automatic resolution mapping with a special option to align grids along the major and installation of build and library dependencies, (c) an fluid flow direction (upstream to downstream), we hope to easy path to replicate installations across systems (including derive some optimization by making streamline computa- binary packages), and (d) easy maintenance of the installa- tion more local to each processor. tion and upgrade process. References MacPorts [1] CFS Engineering: www.cfse.ch/cfse/site/tools-NSMB.php I have provided several references at the end of this article to help other users begin working with MacPorts [1], [2], Jean M. Favre is a research engineer at the [3]. MacPorts have a few easy build and installation options Swiss National Supercomputer Center (CSCS) for Kitware tools on OSX. What could be easier than these in Manno, Switzerland, where he supports installation commands? multiple visualization projects with ParaView, from astrophysics, to biomechanics, fluid $ sudo port install cmake dynamics, geophysics, and molecular dynamics. $ sudo port install InsightToolkit $ sudo port install vtk-devel
Jan Vos, leads CFS Engineering with his The port system has automatic detection of CMake as a build experience in fluid mechanics simulations, dependency, so this works too: including Magneto Hydrodynamic Flows, combustion, hypersonic flows and flows for $ sudo port install InsightToolkit vtk-devel aeronautical applications. Jan is also lecturer at the Laboratory of Computational If CMake is not already installed, this command will run the Engineering at the EPFL. installation. (The build for ITK includes a build for CableSwig,
11 so it’s not a separate build dependency.) To see what is hacking the port to provide the right variant may be the installed for VTK and ITK, use solution for you and thousands of others too. Bugs! The best way to contact a port maintainer about $ port contents vtk-devel any installation problem is to create a ticket at http://trac. $ port contents InsightToolkit macports.org/. Also, you might get some help from macports- Even upgrades are easy to manage. Whenever a port is [email protected]. If you discover functional bugs updated, it can be detected with after the installation, that's likely an upstream issue in the source of the toolkit. $ sudo port selfupdate $ port outdated MacPorts for VTK At the time this article was written there were several ports To proceed with an upgrade, try available for VTK (5.4.2 is in 'vtk-devel'). To find all the VTK ports, try a search like this: $ sudo port upgrade outdated $ port search vtk To uninstall the old ports during the upgrade, use Then, check out the description and the variants with
$ sudo port upgrade –u outdated $ port info vtk-devel To rebuild ports that depend on the upgraded ports, try $ port variants vtk-devel There are variants available for documentation, wrapping, $ sudo port upgrade –uR outdated database connectivity, MPI, and so on. Almost all of the configuration options available in CMake have a variant in Once you start adding in additional contingencies, like the port. MySQL and Qt things can get tricky; often the solution is to simply enable a variant. For example, try a few of the MacPorts for ITK following commands The MacPorts for ITK are available at several recent release versions. To find all the current versions available, use $ port variants InsightToolkit $ sudo port install InsightToolkit +examples $ port variants vtk-devel $ port search InsightToolkit $ sudo port install vtk-devel +mpi +mysql To get the port description and variants, try Issues with MacPorts It may take hours to build and install Kitware libraries. $ port info InsightToolkit Nevertheless, it saves all the headache of fetching release $ port variants InsightToolkit bundles, manual configuration, and fixing tricky link depen- The default variants are indicated with a [+] and variant con- dencies and bugs. By default, MacPorts builds from source, tingencies may be indicated with '*requires' and '*conflicts'. so it is not as efficient as some binary systems, like Yum/rpm At the time this article was written, the defaults included and Debian. (If you prefer a Debian system on OSX, check documentation, shared libs, and wrapping for Java, Python, out "fink".) There are options to enable creation of binary and Tcl. archives from your builds, which can be shipped to other systems in your domain. A significant advantage of MacPorts For a new installation of ITK, at the latest release available, is the dependency resolution architecture that facilitates try careful library linking to other open-source ports that can coexist with the Darwin-OSX system. The dependency reso- $ sudo port selfupdate lution architecture provides library links that can be isolated $ sudo port install InsightToolkit from Apple system upgrades and it can facilitate integrated updates of all packages within MacPorts. It's recommended that you run the installation overnight. For detailed progress on the build and install, use As with almost any package management system, there are some issues with complex software integration. For $ sudo port -d install InsightToolkit instance, consider the problem of integrating VTK with Qt. Just run a search for this online and you will find numerous The -d option is used for 'debug' information, but also serves discussions of many troubles trying to explore all the version as a useful progress meter. When it's complete, you can see compatibility and build contingencies to get these and other everything installed with libraries to cooperate. Sure, you may choose to go it alone and get something working for your system (probably under $ port contents InsightToolkit /usr/local), but you might first consider learning MacPorts and becoming yet another contributor to solving the same ITK Upgrades problem for thousands of developers. To upgrade to a new release of ITK use the following Some of the greatest trouble in building for OSX lies within command choices for the display engine (cocoa, carbon, x11). Some of the libraries use one or another by default for various $ sudo port selfupdate reasons. If you need to change a default display, first look $ sudo port upgrade InsightToolkit at the variants for the port and, if that’s not your solution,
12 The following command can be used to remove a previous are configured for other open-source packages provided installation when performing the upgrade by MacPorts (some utilities or libraries may be provided by Apple). To see dependencies of a port, try $ sudo port upgrade –u InsightToolkit $ port deps InsightToolkit The latest version can coexist with prior versions, such as ITK 3.14. The ports are designed to install into version-specific To take advantage of this when developing ITK, first learn paths and to rename binaries with version-specific names. how to create a "local repository" [5]. Once you have a local The latest release of the port should have symlinks from repository, copy the current Portfile for ITK so that you can generic paths and binaries to the latest version specific modify it (find it using 'port file InsightToolkit'). installation. The port installation process actually comprises several To keep an older version after an upgrade, it may be phases [5]. A developer can stop the installation after the necessary to install a prior version-specific port (e.g., build phase (see 'man port' for all the developer targets). At "InsightToolkit314"). That process could look like this: that point, there is a complete source tree and a separate build tree (with no tweaks to the Portfile, you get a release $ sudo port selfupdate version of ITK, see 'port info InsightToolkit'). To try this $ sudo port upgrade -u InsightToolkit $ sudo port install InsightToolkit314 $ sudo port build InsightToolkit $ macportPath="/opt/local/var/macports" Wrapping for ITK $ buildPath=${macportPath}/build/*InsightToolkit/ Some port hacks were required to get all the library link set- $ ls $buildPath tings right for the Tcl and Python libraries in WrapITK/lib/ (by Then you might try to develop directly in the MacPorts build changing the library paths using install_name_tool). Further tree. If you're tempted to copy the InsightToolkit tree some- hacks were required for the itkwish shell script in ${prefix}/ where else to develop with it, there are some rpath issues bin/itkwish and the binary in WrapITK/bin/itkwish. At the to contend with. One problem with moving the build tree time of testing, itkwish worked and 'import itk' worked for somewhere else is that the OSX convention is to use rpath, Python 2.5. Java wrapping is also available, but it was not so the build tree has a lot of specific links within the build tested for the purposes of this article. tree (many of these are reset during the "destroot" phase and there are a ton of hacks in the InsightToolkit port to get CMake issues the rpath right after the "destroot" phase). To build against a VTK or ITK library, your CMakeLists.txt may have to set the VTK_DIR or the ITK_DIR to be certain Use the following commands if you need to check or correct about linking any CMake configuration settings, or if you need to read and edit your Portfile SET (ITK_DIR /opt/local/lib/InsightToolkit-3.16) SET (VTK_DIR /opt/local/lib/vtk-5.4) $ sudo port configure InsightToolkit <+VARIANTS> $ cd $buildPath # see above The ITK port currently adds a version-specific CMake module, $ sudo cmake -LAH ../InsightTookit-
Development with MacPorts: Acknowledgements InsightToolkit This work involved help from generous developers in the For a MacPorts package, most of the library dependencies open source community, including folks dwelling @cmake.
13 org, @itk.org, @vtk.org (Bill Lorensen, Luis Ibáñez , David Cole, Gaëtan Lehmann, Sean McBride, Michael Jackson, et al.) and the folks @macports.org (Bryan Blackburn, Jeremy Huddleston, Jeremy Lavergne, Rainer Müller, Toby Peterson, Joshua Root, Frank Schmia, Ryan Schmidt, et al.). This work was supported by NIH grant # UL1 DE019608.
Online Resources • For updates and additional details, see the ITK_MacPorts_ Package_Maintainers page at http://www.itk.org/Wiki/. • There is a general reference for OS-X developers at http:// developer.apple.com/mac/library/navigation/index.html • For topics on programming with Mach object files, see: http://developer.apple.com/Mac/library/documentation/ DeveloperTools/Conceptual/MachOTopics/ References [1] http://www.macports.org [2] http://trac.macports.org/wiki/InstallingMacPorts [3] http://trac.macports.org/wiki/FAQ The above figure shows an MR detection study of a patient [4] See http://trac.macports.org/wiki/FAQ for more info. with elevated PSA, where prior ultrasound biopsy could [5] Learn how to create a local repository, read more about the not confirm the presence of cancer. The detection protocol port installation process, and the advanced fetch phase at includes: t2-w, ADC, and DCE-MRI sequences. The radiologist http://guide.macports.org marks a finding, which is suspicious for cancer, with a trans- parent red sphere (vtkUnstructuredGrid) and is presented Darren Weber is staff scientist at the Buck with CADx output to assist in differentiating between benign Institute for Age Research (Novato, CA) and malignant. A malignancy score of .33 (green and red are where he works on microscopy image pro- scores of benign and malignant training findings) indicates cessing. Formerly, he was a postdoctoral that the region is unlikely to contain cancer. This patient is fellow at UCSF, working in human brain currently in an active surveillance program. imaging to investigate attention systems. He holds a PhD in cognitive neuroscience from The Flinders University of South Australia. He enjoys quality time with his daughter, mountain biking in the Marin open-space, and the Zen path to enlightenment. Contact him at psdlw.users.sf.net or [email protected].
MRCAD for Daily clinical analysis of prostate MR
The Diagnostic Image Analysis Group (DIAG) from the Department of Radiology at Radboud University Nijmegen Medical Centre in The Netherlands researches computer- aided diagnosis of breast, lung and prostate cancer. The research in prostate cancer is a collaborative effort with the clinical prostate group in the department and is focused on high resolution anatomical, functional (diffusion and A 59-year-old patient with a PSA of 12 ng/ml and a con- dynamic contrast enhanced) and metabolic (spectroscopy) firmed biopsy Gleason 8 tumor in the right peripheral zone. MR. During various prostate and breast MR projects an The MRCAD hanging protocol shows T2-w transversal (right image analysis workstation, MRCAD, has been gradually view) and in color overlays: Pharmacokinetic DCE-MRI; developed based on VTK, ITK and IncrTCL. This workstation and ADC-map (left upper row); and choline metabolite provides dedicated image analysis tools and display facilities concentration; coronal T2-w image (left bottom row); The for various state-of-the-art MR sequences and hardware separate window shows a time-concentration curve and as well as a platform for testing new computerized image an MR Spectroscopy spectrum at the cursor location. The analysis techniques. Currently, MRCAD is in daily clinical use reporting radiologist rated all 4 modalities 5 on a 5 point at our clinic and at a few other sites. MRCAD is being used scale: where 1 is no tumor, and 5 is definitely tumor. These to reporte prostate MR and in various research projects and MR findings were confirmed retrospectively with a stage T3a publications. This article will address some of the design fea- determined after prostatectomy. tures and explain how VTK, ITK and IncrTCL have been used to achieve a robust, versatile, clinical research platform. Overview of the software The workstation runs an OpenSuse Linux OS. A DCMTK server Screenshots daemon receives DICOM images automatically forwarded by To help understand MRCAD, here are two example cases the PACS system. A polling mechanism triggers automatic
14 pre-processing of MR studies (e.g., fitting DCE-MRI curves). in the markpatient node: a T2c tumor. After reporting the The studies are then ready for viewing and analysis. MRCAD patient case, MRCAD can use the findings stored in the XML features are: compressed, multiframe DICOM Reading/ database to collect screenshots and format the information Writing; multi-modal color overlay; DCEMR pharmacokinetic into a PDF file using dedicated stylesheets. This PDF report is modeling and registration; manual and semi-automatic then sent to the Electronic Patient Database using SOAP: segmentation; region of interest statistics; CADx, CADe; MRS (using LCModel), and Structured Reporting. set token [::http::geturl $posturl -type "text/xml; boundary=''" -headers [list Cookie $sessionid] -que- The MRCAD software has a layered structure as shown ry [$soaprequest asXML]] below. The main programming language is Tcl/Tk with the set body [http::data $token] object oriented extension IncrTcl. Processing and display http::cleanup $token are performed in VTK pipelines that are setup using the Tcl wrapped interface. Local VTK classes provide additional high Coordinate system computational functionality at the C++ level or as means to MRCAD uses three coordinate systems to handle the variety include wrappable ITK functionality. of image volume and voxel dimensions and orientations in an MR scan: ijk voxel location in an MR series, xyz patient posi- tion, uvw viewport coordinate. A vtkDCMTKImageReader directly reads DICOM images in single slice, multiframe, and/ or compressed format and produces a vtkImageData and a vtkTransform (ijk2xyz). The latter transform maps voxel location ijk to an xyz patient position. The viewer uses an additional uvw2xyz transform to handle: zooming, panning and slice selection. This allows for accurate (sub-voxel) overlay of any image (e.g transversal 0.5x0.5x3mm) onto any other orientated image (oblique (15deg) sagital (1x1x4mm)). Arbitrarily shaped 3D volume annotations are created and stored in xyz coordinates using the vtkUnstructuredGrid format. These annotations can be added and overlayed to any view and are also used to compute region of interest Annotation and Structured Reporting statistics in the various multi-modal images. Clinical findings and ground truth for CAD are annotated and stored in XML. Example tags are: tumor location, tumor Data and widget factory grade, scorings, and access time. For structured reporting, The core of the MRCAD application is designed as a factory findings can be collected and added to the XML database. method pattern. The approach ensures fast initializing of A PDF file can be generated from the XML file (using LaTeX) the application, by constructing data objects on demand. As and, after inspection, sent to an Eletronic Patient Database a result, VTK pipelines are only created when needed. An using SOAP requests. The XML data is additionally used IncrTcl coded part of the factory: for training CAD systems, and performing clinical observer studies. An XML example of an observer scoring is: class MRCADDataFactory { ... public {
15 # Register a DiskImageData object on the itkHessianRecursiveGaussianImageFilter to detect [MRCADDataFactory::Instance] AddData "Diff1" lesions. MRCAD is also used in several observer studies that [list DiskImageData $files] are performed by radiologists to determine the diagnostic value of a certain MR modality or protocol. In [6] MRCAD was adds an imagedata object with mapname "Diff1", which is used for scoring DCE-MRI derived parameters and establish constructed by a specialized class DiskImageData (an IncrTcl the value for localizing prostate cancer. Recent use includes wrapper of the vtkDCMTKImageReader). detecting MR suspicious lesions for MR or ultrasound guided To view the diffusion-w image in the application: biopsy and detecting recurrence after radiotherapy [7,8]. if {[[MRCADDataFactory::Instance] IsAvailable References "Diff1"} { [1] Prostate cancer: precision of integrating functional MR # Get the data object and create the VTK imaging with radiation therapy treatment by using fiducial pipeline nescessary to produce the data gold markers (Huisman, et al. Radiology, 2005) set obj [[MRCADDataFactory::Instance] [2] Computerized analysis of prostate lesions in the peripheral GetData "Diff1"] zone using dynamic contrast enhanced MRI (Vos, et al. # Display the image in the viewer Medical Physics 2008) vlSetImage BG [$obj GetVolume] vlSetTransform BG [$obj GetTransform] [3] Computer assisted analysis of peripheral zone prostate } lesions using T2-weighted and dynamic contrast enhanced T1-weighted MRI (Vos, et al. PMB 2010) Data objects can be accompanied by data widgets to allow [4] Automated calibration for computerized analysis of pros- user interaction with the data object. In the image below, tate lesions using pharmacokinetic magnetic resonance the spectroscopic metabolite image data object output is images (Vos, et al. MICCAI 2009 displayed as a transparent, color-coded overlay on top of a [5] Computer-aided Detection of Prostate Lesions at Diffusion- T2-w image. Multiple metabolite maps are available and the weighted MR Using a Dedicated Hessian Matrix–based accompanying data widget allows selection of the metabolite Detection Scheme (Vos et al. RSNA, 2009 Chicago) and provides other interactions with the data object. Here, [6] Prostate cancer localization with dynamic contrast- the 3th available metabolite, choline (Cho), is selected: enhanced MR imaging and proton MR spectroscopic imaging (Futterer, et al. Radiology 2006) [7] Magnetic resonance imaging guided prostate biopsy in men with repeat negative biopsies and increased prostate specific antigen (Hambrock, et al. Journal of Urology 2010) [8] Feasibility of 3T Dynamic Contrast-Enhanced Magnetic Resonance-Guided Biopsy in Localizing Local Recurrence of Prostate Cancer After External Beam Radiation Therapy (Yakar, et al. Investigative Radiology 2010) Henkjan Huisman is an Assistant Professor in the Diagnostic Image Analysis Group in the Department of Radiology at Radboud University Nijmegen Medical Centre. His research interests include computer aided diagnosis, image segmentation, prior knowledge integration in image analysis, and pharmacokinetic MRI. Pieter Vos is a PhD student at the Diagnostic Image Analysis Group in the Department of Radiology at Radboud University Nijmegen Medical Centre where he's working on Research overview Computer Aided Diagnosis of prostate cancer MRCAD is used in a number of research projects. MRCAD was using multimodal MR. used to detect and annotate the Dominant Intraprostatic Lesion for radiotherapy IMRT planning [1]. A successful Computer Aided Diagnosis system has been researched and implemented to discriminate benign from malignant sus- MATLAB® AND GNU R INTEGRATION piscous regions using region of interest statistical features derived from DICOM images directly or processed paramet- WITH VTK NOW AVAILABLE ric maps [2]. Pattern recognition as well as ROC analysis was performed using the statistical package R. Pharmacokinetic The software integration work discussed in the October 2009 features computed from Dynamic Contrast Enhanced MRI issue of Kitware Source, MATLAB® and GNU R Integration, is provided the highest diagnostic accuracy. Subsequently in now available on the main development branch of VTK. The [3], more modalities/features were added to improve the dis- integration classes are located in the VTK/Graphics directory. criminating performance. An ITK-based registration method The MATLAB integration classes are: vtkMatlabMexAdapter, was extended with a local incompressibility term to add vtkMatlabEngineInterface, and vtkMatlabEngineFilter. The MR series features that were misaligned by possible patient GNU R integration classes are: vtkRAdpater, vtkRInterface, movement during acquisition. Currenty, [4] and [5] an initial vtkRCalculatorFilter, and vtkRRandomTableSource. system for fully automatic detection of prostate cancer is The VTK/Graphics/Testing/Cxx directory contains unit tests being developed using a locally developed vtkClass based for these integration classes which illustrate the basic usage
16 of their interfaces. There are also Python examples located The R libraries are normally located in
BUILDING VTK WITH GNU R integration A build from source of GNU R 2.9.0 or newer is required. Please consult http://www.r-project.org/ for downloads and build instructions. A word of caution, the GNU R build process is considerably easier on Mac and Linux than on Windows. A micro-CT scan of a trilobyte fossil rendered with the GPU ray caster. Dataset courtesy of Thomas Kircher. Samples were from The CMake option to turn on the GNU R integration code the University of Alaska Fairbanks Department of Geology and during the build is under advanced options as VTK_USE_ Geophysics collection courtesy of Dr. Sarah Fowell. GNU_R. The CMake system will attempt to locate the R installation, but most likely some manual specification of This mapper has been added to the suite of volume mappers library and include paths will be necessary. The CMAKE vari- available in Slicer. As part of a Sandia-funded effort, this able R_INCLUDE_DIR is the full path to the R installation mapper is also being added to ParaView's available volume include directory, normally under
17 descriptive in intra-surgical motion and tissue morphology; biomechanics must be faithful to tissue response; haptics KITWARE NEWS must afford multi-tool interaction; and the system must meet clinical requirements reflecting the specific surgical approach and pathology. Kitware Awarded $600K NIH Grant to advance neurosurgical simulation The project will employ ITK to produce a descriptive and Kitware has received a two-year grant from the National patient-specific application modeling brain anatomy, Institutes of Health (NIH) totaling more than $600,000 to requiring innovations in segmentation, registration and focus research efforts on developing approach-specific, meshing; VTK for interactive visualization; and the research multi-GPU, multi-tool, high-realism neurosurgery simulation. will expand Kitware’s new Vessel Toolkit. This project will The goal of the research is to work toward an interactive also build on Kitware’s expertise in GPU programming and simulator that replicates future neurosurgery cases of young haptics. Through this proposed work, Kitware will expand surgeons, enabling hospitals faced with compressed intern its leadership in computer vision toward advancements for schedules to accelerate training and improve skills. photorealistic rendering in surgery simulation, as well as pursue research in medical ontologies. “Simulation has made limited inroads in neurosurgery despite its proven advantages over traditional surgical train- Mastering CMake now available ing,” said Dr. Michel Audette, R&D Engineer at Kitware. Kitware is pleased to announce the release of the Fifth Edition “Our objective is to empower the neurosurgical field with of Mastering CMake. This edition features instructions for simulation training methods that directly correlate to better, building your own project with CMake; information on how more accurate patient care.” to update a project for new versions of CMake by explaining the CMake policy system; and a discussion of how to setup Historically, simulation has over-emphasized needle insertion and customize a CDash dashboard including the creation of and failed to address requirements of surgeons-in-training on subprojects. potential caseloads. Existing simulators do not ably reconcile the conflicting clinical requirements of neurosurgery; their underlying models are insufficiently sparse to resolve large tissue displacements and they are insufficiently descriptive of critical tissues at risk in each intervention.
As always, Mastering CMake includes: • Instructions for downloading, installing, and running CMake on many platforms including Linux (UNIX), Microsoft Windows, and Mac OSX. • Details on how CMake works and how it impacts your build scripts. • Instructions for running the different GUIs, including command line options. This NIH-funded research will involve innovations in controlled- • Information on how to use CTest to perform software resolution meshing, with prior work of Dr. Audette's shown for testing. surface and tetrahedral meshes for pituitary surgery in (a) and (b), in conjunction with multi-rate finite elements. It will also integrate • A full reference of CMake's commands and variables with innovations in interactive nonlinear finite elements (not shown), descriptions. highly descriptive knife- and scissor-like haptic interaction (c), and approach and pathology-specific surgical ontologies (d). The Fifth Edition of Mastering CMake may be purchased through Kitware's secure online store or through Amazon Kitware will set out to prove that for interactive neurosurgery (ISBN-13: 978-1-930934-22-1). Please contact Kitware directly simulation to be relevant and technically feasible, the follow- at [email protected] for discounted rates on purchases of ing has to occur: anatomical modeling must be sufficiently 10 or more books.
18 VTK User's Guide now Available Additional course information is available on our website or Kitware is pleased to announce the release of the Eleventh by emailing [email protected]. Kitware also offer custom- Edition of the VTK User’s Guide. The VTK User's Guide ized courses at both on- and off-site locations. If you have is a companion text to The VTK Textbook; while The VTK training needs which aren't met by our standard course or if Textbook stresses algorithmic and data structure details, the our current training dates don't work for your organization, VTK User's Guide stresses how to use the software. a customized course may be right for you. Please contact a Kitware representative to discuss customized options. The Eleventh Edition features a new chapter detailing VTK's information visualization functionality, including the table, The end of the experiment graph, and tree data structures required to represent non- Back when we first created VTKEdge several years ago, spatial data; enhanced details on 2D and 3D widgets and we decided to experiment with a dual licensing model in other forms of user interaction required to create an explor- an attempt to satisfy both our open source community and atory visualization application; a new chapter on geospatial the reviewers of our SBIR / STTR proposals. Before that, we visualization for geographically organized data; additional would either release the code into our open source projects details on time dependent and composite data; and a dis- (keeping the community happy, but making the reviewers cussion of advanced rendering techniques, including depth concerned about our sanity when our revenue model started peeling for transparency. with giving everything away for free) or we would keep the As always, the VTK User’s Guide includes: code proprietary and attempt to license it (alienating our open source community, but satisfying the commercializa- • A description of the structured and unstructured data tion requirements for our proposals). After a few years we types supported by VTK. can now safely say that this experiment was a failure. Not • Details on the pipeline architecture model. only did we annoy our open source community by adopting • An overview of the rendering engine used to display a reciprocal license, we did not actually satisfy the reviewers data. who were now even more perplexed by a plan that included • Many examples showing the use of various scalar and both giving away and selling the same code. vector visualization and data processing algorithms. We are pleased to announce the end of this experiment. The • Chapters dedicated to image processing and volume ren- VTKEdge toolkit has migrated from using the GPL to a BSD dering. license compatible with VTK and ITK. Some of the VTKEdge • Information on how to write your own algorithms in VTK, functionality has actually been ported into VTK and ParaView including details on the VTK coding style. (the LIC painters and the GPU ray cast mapper). As funding The Eleventh Edition of the VTK User’s Guide may be pur- permits, more functionality will migrate and, eventually, chased through Kitware's secure online store or through VTKEdge will cease to exist. We are also happy to say that Amazon (ISBN-13: 978-1-930934-23-8). Please contact reviewers are no longer quite as bewildered by an open Kitware directly at [email protected] for discounted rates source business model, although it is still challenging to on purchases of 10 or more books. quantify an agency's return on investment when the results are all distributed open source. So, if you are using one of our open source tools in your work, please let us know. Your success stories and your wish lists for new functionality can help us justify future research by showing that the impact of the effort goes far beyond Kitware. Summer Conferences and Events If you’re interested in meeting with a Kitware representative at one of these events, email us at [email protected].
Turning Images to Knowledge: Large-Scale 3D Image Annotation, Management, and Visualization May 9 - 12, in Ashburn, VA. This conference will stress the importance of extracting useful and biologically relevant knowledge from image contents in a systematic, compre- hensive and high-throughput way. Dr. Luis Ibáñez will be presenting a paper about collaboration platforms at this year's event. http://www.hhmi.org/janelia/conf-045.html
CVPR 2010 June 13 - 18, in San Francisco, CA. http://cvl.umiacs.umd.edu/ conferences/cvpr2010/
NA-MIC Project Week June 21 - 25, in Boston, MA. Will Schroeder, President and Developer's Training week CEO, and Stephen Aylward, Director of Medical Imaging, Kitware’s Developer’s Training Week will be held May 3 - 6, will be in attendance. http://www.na-mic.org/Wiki/index. in Albany, NY. The course is a hands on experience covering php/2010_Summer_Project_Week VTK, ParaView, ITK, and CMake and is suitable for both new users of these open source projects as well as more advanced CARS 2010 developers. Basic knowledge of C++ is recommended. June 23 - 26, in Geneva. http://www.cars-int.org/
19 OSCON 2010 member of the researech team at INRIA-Lorraine where he July 19 - 23, in Portland, OR. Dr. Luis Ibáñez will be pre- worked on the LibreSource project. He received a Master's senting a talk on "Educating the Next Generation of FOSS Degree in Computer Science from the ESSTIN Engineering Developers" on Thursday July 22 at 1:40 p.m. in D133 as part School in France. of OSCON's first designated education track. http://en.oreilly. com/oscon2010 Internship opportunities Kitware Internships provide current college students with SIGGRAPH 2010 the opportunity to gain hands-on experience working with July 25 - 29, in Los Angeles, CA. Aashish Chaudhary and leaders in their fields on cutting edge problems. Our busi- Francois Bertel will be in attendance. http://www.siggraph. ness model is based on open source software—an exciting, org/s2010/ rewarding work environment. ICPR 2010 At Kitware, you will assist in the development of founda- August 23 - 26, in Istanbul, Turkey. http://www.icpr2010.org/ tional research and leading-edge technology across our five business areas: supercomputing visualization, com- IEEE Cluster 2010 puter vision, medical imaging, data publishing and quality September 20 - 24, in Heraklion, Crete, Greece. http://www. software process. We offer our interns a challenging work cluster2010.org/ environment and the opportunity to attend advanced soft- ware training. Apply by sending your resume to internships@ MICCAI 2010 kitware.com. September 20 - 24, in Beijing, China. Michel Audette willbe in attendance. http://www.miccai2010.org/ employment opportunities Kitware has an immediate need for talented Software New Employees Developers, especially those with experience in Computer Robert Maynard Vision, Scientific Computing and Biomedical Imaging. Robert Maynard joined the Scientific Computing Group at Qualified applicants will have the opportunity to work with Kitware in March 2010. Robert received his B.S. in Computer leaders in computer vision, medical imaging, visualization, Science from Laurentian University in Sudbury, Ontario in 3D data publishing and technical software development. May 2007. After graduating Robert spent 3 years at MIRARCO Kitware team members enjoy our small company environ- where he was the primary programmer on ParaViewGeo, a ment, flexibility in work assignments and high levels of fork of ParaView designed for the mining industry. While at independence and responsibility. We offer comprehensive MIRARCO, he worked on several internal projects focusing benefits including: flexible work hours; six weeks paid time on visualization for the mining industry. off; a computer hardware budget; 401(k); health insurance; Sébastien Jourdain life insurance; short-and long-term disability; visa process- ing; and free drinks and snacks. Sébastien Jourdain joined Kitware in February 2010 where he is currently working on the collaborative aspects of ParaView. Qualified candidates, especially those with experience Prior to joining Kitware, Sébastien developed open source in computer vision, scientific computing, and biomedical software projects at Artenum for research laboratories and imaging, are encouraged to send their cover letter and various French companies. Sébastien was also previously a resume to [email protected].
In addition to providing readers with updates on Kitware Kitware’s Software Developer’s Quarterly is published by product development and news pertinent to the open Kitware, Inc., Clifton Park, New York. source community, the Kitware Source delivers basic infor- Contributors: Lisa Avila, Utkarsh Ayachit, Katie Cronen, mation on recent releases, upcoming changes and detailed Jean Favre, Paul Fitzpatrick, Zack Galbreath, Bill Hoffman, technical articles related to Kitware’s open-source projects. Henkjan Huisman, Luis Ibáñez, Matt McCormick, Nicole These include: Messier, Giorgio Metta, Lorenzo Natale, Thomas Otahal, Jan • The Visualization Toolkit (www.vtk.org) Vos, Pieter Vos, and Darren Webber. • The Insight Segmentation and Registration Toolkit (www.itk.org) Creative Director: Melissa Kingman, www.elevationda.com • ParaView (www.paraview.org) • The Image Guided Surgery Toolkit (www.igstk.org) Graphic Design: Steve Jordan • CMake (www.cmake.org) Editor: Niki Russell • CDash (www.cdash.org) Copyright 2010 by Kitware, Inc. or original authors. • MIDAS (www.kitware.com/midas) • BatchMake (www.batchmake.org) The material in this newsletter may be reproduced and dis- • VTKEdge (www.vtkedge.org) tributed in whole, without permission, provided the above copyright is kept intact. All other use requires the express Kitware would like to encourage our active developer permission of Kitware, Inc. Kitware, ParaView, and VolView community to contribute to the Source. Contributions may are registered trademarks of Kitware, Inc. All other trade- include a technical article describing an enhancement you’ve marks are property of their respective owners. made to a Kitware open-source project or successes/lessons learned via developing a product built upon one or more To contribute to Kitware’s open source dialogue in future of Kitware’s open-source projects. Authors of any accepted editions, or for more information on contributing to specific article will receive a free, five volume set of Kitware books. projects, please contact the editor at [email protected].
20