Issue 24 •

Editor's Note ............................................................................... 1

Recent Releases ......................................................................... 1

VTK and ParaView Add Highly Configurable Particle Tracker ........................................................................................ 2

ParaView Aids In Silico Modeling and Visualization for Fracture Fixation in Osteoporotic Bone ..................................... 4

3D Slicer Improves Testing for Pull Requests Using Docker and CircleCI................................................................................. 6

3D Slicer Resamples Ultrasound Images ............................... 10

Kitware News ............................................................................ 14

ITK INCREASES SUPPORT AND GAINS REMOTE MODULES IN VERSION 4.11The development team for the Insight Segmentation and Registration Toolkit (ITK) released version 4.11.0 to offer exciting features thanks to the contributions of over 30 community members. Among its highlights, the release enabled NumPy bridge support by default. The support permits NumPy array views of multi-component images as well as vectors and matrices. The release also added a filter for edge enhancement, itk::UnsharpMaskImageFilter, and it updated the Hierarchical Data Format 5 (HDF5) library and other third-party libraries to the latest upstream versions.

Moreover, ITK acquired a number of remote modules. These modules perturb mesh vertices with additive Gaussian noise; accurately benchmark computational performance; complete principal component analysis of scalar, vector, and mesh vertex data; create a run-length encoded memory compression scheme for itk::Image; run n-dimensional morphological contour interpolation; interpolate multi-label images; iterate over multiple images simultaneously; and compute an inverse displacement field, respectively.

More information on the latest release of the open-source software solution is available at https://itk.org.

Version 4.11 makes it possible to apply the MorphologicalContourInterpolation module to innovative applications like ITK-SNAP and 3D Slicer.

TABLE OF CONTENTS RECENT RELEASES

Issue 40 • January 2017

We begin a new year with the 40th issue of our quarterly newsletter, which has circulated for over a decade! This issue shines the spotlight on the Insight Segmentation and Registration Toolkit (ITK), the Visualization Toolkit (VTK), ParaView, and 3D Slicer. Throughout the past year, these open-source software solutions have witnessed growth with improved performance and advanced features.

In 2016, our company grew as well. We hired 18 team members, over half of whom filled new positions. In 2017, we strive to hire for additional positions such as system administrator in Carrboro, North Carolina. We also plan to reveal a new website, https://kitware.com, which will feature a WordPress design.

Want more news, recent releases, and anecdotes about our open-source solutions? Find us on social media:

• Twitter (https://twitter.com/Kitware);

• Facebook (https://www.facebook.com/kitware);

• Google+ (https://plus.google.com/111200425937199925962);

• LinkedIn (https://www.linkedin.com/company/kitware-inc-);

• Instagram (https://www.instagram.com/kitware_inc); and

• Vimeo (https://vimeo.com/kitware).

EDITOR'S NOTE

2

To begin the process of particle tracking, seed input injects particles in the flow. The particles then integrate with specific equations and with data from flow input. Particle tracking continues until the particles meet terminal condi-tions and stop.

In addition to three inputs, LagrangianParticleTracker has two outputs: ParticlePaths and ParticleInteractions. ParticlePaths is a vtkPolyData data object of polylines that shows the paths of particles in the flow. ParticleInteractions is a vtkPolyData data object of vertices with the same composite layout of surface input. ParticleInteractions shows all interactions between particles and surface input. It remains empty if no surface input exists.

DYNAMIC INTEGRATION MODELThe main parameter of LagrangianParticleTracker is its integration model. VTK already implements a model, vtkLagrangianMatidaIntegrationModel [1]. While it is pos-sible to implement other models within the toolkit, one of the design strengths of LagrangianParticleTracker is that it allows developers to create their own models as ParaView plug-ins, load them into ParaView, and use them on the go.

An example shows the use of LagrangianParticleTracker with

vtkLagrangianMatidaIntegrationModel.

Example plug-ins exist in ParaView that demonstrate how to implement and utilize new models. For instance, the models must inherit code from the base model, vtkLagrangianBasicIntegrationModel. In addition, the models must implement their respective FunctionValues methods to integrate particles.

Integration models make it possible to set which equations to employ. The models also come with various features. While most of these features remain empty in vtkLagrangianBasicIntegrationModel and

VTK AND PARAVIEW ADD HIGHLY CONFIGURABLE PARTICLE TRACKER

Mathieu Westphal (Kitware)

Particle trackers and streamlines serve as important tools in multiple scientific domains such as fluid dynamics, ther-modynamics, medicine, and biology. Since the creation of the Visualization Toolkit (VTK) and ParaView, support for these tools has improved. Tools such as the StreamTracer filter in ParaView have become widely used in the VTK and ParaView communities of users. Such tools have specific uses, and they are not quite configurable in terms of equa-tions. VTK and ParaView have a new filter, however, called LagrangianParticleTracker, which offers a completely configurable implementation of the Lagrangian Particle Tracking (LPT) algorithm.

The idea behind particle tracking is to inject, integrate, record, and display particle trajectories. The work for the new filter focused on providing a particle-centered imple-mentation of the LPT algorithm that includes a dynamic equation model and optional surface interactions, among other features.

In this simple illustration of particle tracking, t=0, t=1, t=2, and t=3

correspond to particle positions at different integration times.

The inputs of the filter include the following: seed (source) input, flow input, and optional surface input. Seed input contains a dataset with a point on which to generate par-ticles, any kind of data object, and support for distributed input. This input only uses the first leaf of a composite dataset. Flow input contains a volumetric dataset that inte-grates with particles, any kind of data object, and support for distributed input. Optional surface input contains a dataset that interacts with particles, any kind of data object, and support for distributed input.

3

vtkLagrangianMatidaIntegrationModel, other models can implement them. The features are as follows: user-defined equation variables, free-flight termination, PreProcess and PostProcess methods, manual integration and manual particle-shifting capabilities, access to data from all three inputs, and surface interactions.

Particles interact with a surface.

The surface interactions that the base model supports include terminate, bounce, break up, and pass through. Terminate stops the integration of a particle when it reaches a terminating surface. Bounce makes the particle ricochet off the surface with basic reflection code. Break up derives from bounce. Break up terminates the initial particle and creates two new particles. Pass through allows a par-ticle to go undisturbed and records its advance in surface interaction output.

Particle paths demonstrate pass through.

ADDITIONAL FEATURESLagrangianParticleTracker supports many other features. The filter makes it possible to select the type of integrators to use as well as the type of locator to use to find cells in flow input and surface input. The filter also makes it possible to select different types of cell-length computation (e.g., a divergence theorem-based algorithm) to plan when to integrate particles. In addition, LagrangianParticleTracker supports reseeding, which means that it can use the surface interaction output from one case of particle tracking as seed input for a second case of particle tracking.

LagrangianParticleTracker exemplifies reseeding.

LagrangianParticleTracker also has a parallel imple-mentation, which streams particles between domains and offers ghost cell management. For this parallel imple-mentation, LagrangianParticleTracker can distribute seed input, surface input, and flow input and make any necessary reductions.

LagrangianParticleTracker uses its parallel implementation.

On the ParaView side, LagrangianParticleTracker comes as a default plug-in that contains helpers. One helper sets the necessary variables on the surface for use as surface input. A second helper interpolates or manually sets variables on the point of a dataset on which particles will generate for use as seed input. Both of these helpers are model dependent; they have dynamic interfaces that adapt to the model in use.

For those interested in learning more about and leveraging LagrangianParticleTracker, Kitware offers consulting and support services for VTK and ParaView. For more infor-mation on LPT, please contact kitware@kitware.com.

REFERENCES[1] Matida, Edgar Akio, Warren H. Finlay, Carlos F. Lange, and

Biljana Grgic. "Improved numerical simulation of aerosol deposition in an idealized mouth–throat." Journal of Aerosol Science 35, no. 1 (January 2004): 1-19. doi: http://dx.doi.org/10.1016/S0021-8502(03)00381-1.

Mathieu Westphal is developer for VTK and ParaView. His areas of experience include fluid dynamics, adaptive optics, and visual-ization pipelines.

4

PARAVIEW AIDS IN SILICO MODELING AND VISUALIZATION FOR FRACTURE FIXATION IN OSTEOPOROTIC BONEJean M. Favre (Swiss National Supercomputing Centre), Juri Steiner (Eidgenössische Technische Hochschule Zürich)

Steiner et al. note that osteoporosis has become more common in today’s aging population [1]. Treating fractures in patients with osteoporosis has also become more difficult, as implants such as titanium screws and plates impair the microstructural quality of bones [1]. The image below pro-vides an example.

An X-ray image contains a bone implant with a plate and screws.

According to Steiner et al., in vitro biomechanical tests can examine the mechanical efficacy of implants, but they come with significant costs [1]. Computational specimen-specific models, however, allow a single bone specimen to undergo multiple mechanical tests [1]. Steiner et al. use micro- computed tomography (micro-CT) based finite element (µFE) analysis, which tests bone-screw models in silico [1]. This analysis employs micro-CT to scan a specimen at a nominal isotropic resolution of 20 µm [1].

The image below offers an example.

An in silico model shows the effective strain on a bone specimen.

The ParaSol solver is used for these µFE models and runs on the leading Cray supercomputers at the Swiss National Supercomputing Centre (CSCS). Models typically range in size from 50 to 500 million hexahedral cells, and they pair well with the state-of-the-art data processing and analysis algo-rithms and the advanced rendering methods in ParaView. This article describes the current state of the implementa-tion of ParaView at CSCS, which has grown over the last few years.

PARALLEL READINGParaSol stores the models in Hierarchical Data Format 5 (HDF5) as a single mesh of hexahedral elements. The soft-ware encodes materials (e.g., bones, screws, and plates) as an unsorted element-based variable. ParaView reads data in parallel due to the sheer size of the data. The size of the model shown above (414 million hexahedra) requires the use of 32 Cray nodes with 32 GB of memory. Eah node allocates four Message Passing Interface (MPI) tasks for an average of three to five million cells per task.

ParaSol stores the mesh data in a sequence order that cor-responds to the scanning device. To promote the use of large block input/output and to read consecutive node numbers, the CSCS team reads data by chunks. ParaView spreads the total number of cells among pvserver tasks, renumbers the nodes, sorts the material locally, and performs MPI gather/broadcast operations to enumerate the number of materials.

5

SURFACE EXTRACTION, GHOST CELL GENERATION, AND VISUALIZATIONThe very porous nature of human bones exacerbates the visu-alization challenge. A slice through a bone sample readily illustrates the challenge in the image below. Computing an external surface mesh results in unusually high triangle and vertex counts, as many bone filaments make up the whole structure. The specimen shown below has 92 million hexahe-dra, 10 million vertices, and an external surface of 34 million triangles—a reduction factor of barely one third! The recent move to OpenGL2 rendering and the improved edge render-ing with Fast Approximate Anti-Aliasing (FXAA) in ParaView have increased rendering speed for these very large surfaces.

A longitudinally sliced specimen uncovers the trabecular nature of the bone tissue.

Yet, the hexahedral mesh (a by-product of the ortho-normal computerized axial tomography scan device) does not have a smooth external surface. While ParaView provides a Smooth filter, ghost cells must be created at processor boundaries to ensure the continuity of the surface. In previous versions of ParaView, the D3 filter evenly divided data across proces-sors into spatially contiguous regions with a K-dimensional tree. This resulted in massive data migration from the natural mono-axis cell ordering that originated from the scanning device, as the right-hand portion of the image below illustrates.

GhostCellGenerator (left) and D3 (right) perform processor coloring.

The team at CSCS spontaneously adopted the GhostCellGenerator filter, which the ParaView develop-ment community introduced in 2016 [2]. This filter does not redistribute the input data; it only generates ghost cells at

processor boundaries. To do so, it fetches the topological and geometrical information of those cells on neighbor ranks. The filter can benefit from global point IDs, which a plug-in created by the CSCS team provides. The team tested D3 and GhostCellGenerator with an input mesh of 285 million hexahedra. GhostCellGenerator proved much better both in memory consumption and in performance, as the table below indicates.

Hardware(nodes x MPI Tasks)

16 nodes x 4 MPI tasks

Crash 30.1

32 nodes x 4 MPI tasks

31.8 21.07

64 nodes x 4 MPI tasks

21.02 12.8

D3(exectution time in seconds)

GhostCell Generator(execution time in seconds)

Tests record the execution times for D3 and GhostCellGenerator.

REAL-TIME RAY TRACINGThe intricate and complex internal surface of bones requires advanced rendering. The image below illustrates this fact unequivocally. A new rendering capability in ParaView aug-ments dull renderings of the past—see the top of the bone sample—with shadows and takes into account the reduced visibility of pixels deeper within the bone structure. OSPRay, the open-source interactive ray-tracing library from Intel®, provides this new capability and enables real-time rendering of large models at CSCS [3].

A composite image compares dull rendering (top) to OSPray rendering with shadows (bottom).

6

Mayeul Chassagnard, Jean-Christophe Fillion-Robin (Kitware)

3D Slicer is an industry-leading, free, open-source software platform for medical image informatics, image processing, and three-dimensional (3D)/four-dimensional (4D) visual-ization. In the last five years, over 230,000 downloads of the software have occurred. Since its early age, a rigorous software process has been central to the development of 3D Slicer. Currently, more than 650 tests validate that 3D Slicer and its different components work as expected.

The Kitware blog post “Why should we spend time writing tests?” offers the following quote from Luis Ibáñez, Ph.D. “The safe assumption is: if it is not tested, it is broken” [1]. This quote summarizes the importance of software testing. Software testing serves as a key component of the scientific ecosystem, as it enables reproducible research. The 3D Slicer testing infrastructure also enables adherence to "Rules for tools" [2]. Dr. Ron Kikinis, who serves as the Robert Greenes distinguished director of biomedical informatics in the department of radiology at Brigham and Women's Hospital, first defined these informal rules, which developers should keep in mind when they work on interactive tools for trans-lational clinical research.

Concepts, Tools, and ServicesBefore this article covers the most recent improvements to the 3D Slicer software process, it describes the concepts, tools, and services that support 3D Slicer development.

Continuous Integration

As the Wikipedia article for continuous integration outlines, “In software engineering, continuous integration (CI) is the practice of merging all developer working copies to a shared mainline several times a day” [3].

CTest

CTest is a language-agnostic testing harness that comes with CMake [4]. After CMake creates tests as part of a project build, CTest executes them [4]. Within 3D Slicer, CTest drives the execution of unit tests, which check that individual classes work as expected. CTest also drives the execution of integration tests, called “self-tests.” Users can execute self-tests after they install 3D Slicer and enable developer mode.

A given self-test downloads data and checks that the cor-responding biomedical workflow, which generally involves multiple modules, functions as expected. Most of the 3D Slicer tutorials have corresponding self-tests that evaluate whether or not changes to 3D Slicer break the tutorials. Additional information on self-tests is available at https://www.slicer.org/wiki/Documentation/Nightly/Developers/

3D SLICER IMPROVES TESTING FOR PULL REQUESTS USING DOCKER AND CIRCLECI

SUMMARYParaView has made a tremendous contribution to the visualization needs of CSCS. From distributed mesh manage-ment with ghost cell generation to advanced rendering, the implementation of ParaView has greatly contributed to the analysis of in silico fracture fixation implants in osteoporotic bones at CSCS.

REFERENCES[1] Steiner, Juri, Harry Van Lenthe, Stephen J. Ferguson, and

Jean M. Favre. "In-silico Modeling for Fracture Fixation in Osteoporotic Bone." In Proceedings of the International Conference on High Performance Computing, Networking, Storage and Analysis, 89. Proceedings of SC13, Colorado, Denver. Institute of Electrical and Electronics Engineers, 2013. http://ieeexplore.ieee.org/xpl/mostRecentIssue.jsp?punumber=6869133.

[2] Quammen, Cory, Utkarsh Ayachit, Andy Bauer, David DeMarle, Sujin Philip, David Lonie, and Ken Martin. "ParaView 5.2.0 Release Notes." Kitware Blog, November 15, 2016. https://blog.kitware.com/paraview-5-2-0-release-notes.

[3] DeMarle, David. "VTK and ParaView – now with ray traced surface rendering." Kitware Blog, May 11, 2016. https://blog.kitware.com/vtk-and-paraview-now-with-ray-traced-rendering.

Jean M. Favre is the visualization task leader at CSCS in Lugano, Switzerland. His interests focus on high-performance computing and visualization.

Juri Steiner recently completed his doctoral thesis at Eidgenössische Technische Hochschule Zürich on the validation of patient-specific computer models that simu-late the mechanical behavior of fracture fixation implants in osteoporotic human

bone. His interests include high-resolution computed tomog-raphy, patient-specific finite element analysis, and biomechanical experiments.

7

Tutorials/SelfTestModule. More details on the CMake testing cycle is available at https://cmake.org.

CDash

According to its website, “CDash is an open-source, web-based software testing server” [5]. The server “aggregates, analyzes, and displays the results of software testing pro-cesses,” which CTest drives [5]. 3D Slicer developers can easily verify the state of the current 3D Slicer software and the state of associated extensions on http://slicer.cdash.org/index.php?project=Slicer4.

Pull Requests

Pull requests allow developers to propose and discuss changes before they become integrated into the main line (also known as the “trunk” of the code base or the “master” branch). Practically speaking, anyone can fork the 3D Slicer code base on GitHub and create pull requests. To date, 3D Slicer has received more than 615 pull requests. More infor-mation on pull requests is available at https://github.com/Slicer/Slicer.

On a historical note, the introduction of Git and the use of GitHub to manage the 3D Slicer code base occurred in 2010. The year 2011 marked the first pull request, which occurred a few weeks after the National Alliance for Medical Image Computing (NA-MIC) Summer Project Week hackathon. Until recently, pull requests only served as platforms for discussing and reviewing changes.

THE CHALLENGEBuild servers that Kitware maintains and build scripts run every night on Linux, Mac, and Windows operating systems made it possible to consistently verify that changes in the main line did not break the build and/or cause tests to fail. While the use of nightly builds validated changes, simply relying on them delayed the development cycle. Fixes, for example, could not undergo validation until the next day. To speed up the development cycle, it was important to verify fixes as soon as they became integrated into the main line.

An initial attempt to speed up the development cycle con-sisted of systematically testing all the changes in the main line. Every few minutes, the build servers described above downloaded the most recent changes. These changes trig-gered project builds and tests, the results of which appeared on the dashboard.

Changes get directly integrated with master.

master branch

INEFFICIENT

regularly builds and

undergoes testing

The former testing approach automatically builds and tests the

master branch at a fixed interval.

This approach turned out to be ineffective for the reasons that follow:

• Fixes for changes that occurred at the end of the day still had to wait until the next day for validation. Sometimes, however, developers moved on to other tasks before they attended to the regressions.

• It took time to identify the source of a regression. Since the build servers did not test each change or set of changes independently, they required manual intervention to understand the problem and notify the associated developers.

• The creation of another independent 3D Slicer build tree had to occur before the faster increment build could start, as the build tree associated with nightly testing had to remain untouched to allow CMake tools to build, test, and package the 3D Slicer extensions.

IMPROVEMENT 1 Every night (and up until the next morning), the build servers build and test the most recent changes to 3D Slicer, build updated 3D Slicer extensions against the most recent version of 3D Slicer, and build updated extensions against the last 3D Slicer release. Accordingly, the 3D Slicer development team looked to improve the developer experience.

The 3D Slicer dashboard lists build and test results from November 25, 2016.

8

The Use of CircleCI and Docker to Continuously Build 3D SlicerThe team leveraged the following cloud services that come free to open-source projects.

Docker HubDocker Hub is a cloud-based registry that links code reposito-ries and builds Docker images. A Docker image represents a lightweight container that can run any version of Linux. Said differently, a Docker image enables software re-execution to occur in the same context to assure that results remain con-sistent. More information on Docker is available at https://www.docker.com.

Dockerfile A Dockerfile is a text document that contains all the com-mands that can assemble an image. Many commands can describe this document such as RUN, COPY, VOLUME, ENV, ARG, and even LABEL. These commands offer the abilities to execute processes, mount directories, set some environ-ment variables, and describe an image each time it builds with docker build. Once an image builds, it can undergo instantiation to become a container. Information about best practices on how to write a Dockerfile is available at https://docs.docker.com/engine/userguide/eng-image/ dockerfile_best-practices.

CircleCI

CircleCI is a hosted continuous integration and continuous delivery service. Compared to other services such as AppVeyor or Travis, CircleCI offers built-in efficient support for Docker. CircleCI can link with GitHub and launch a script for every pull request. It refers to the circle.yml file, which has to appear in the source root folder of a project. More informa-tion on CircleCI is available at https://circleci.com.

Required ImagesSystematically building 3D Slicer pull requests with CircleCI requires a 3D Slicer Docker image (or a set of images) that can complete a 3D Slicer build in under two hours. With the help of Matt McCormick, Ph.D., the 3D Slicer development team came up with the following set of images.

thewtex/centos-build

This image provides a build environment that stems from an old Linux distribution (Centos 5). The build environment depends on an older version of GlibC (2.5), and it supplies a recent toolchain (Red Hat devtoolset-2), which provides gcc-4.1.2-55. Since the build environment depends on an older version of GlibC, it enables the creation of binaries that are compatible with most of the current Linux distribu-tions. The ABI Laboratory website illustrates the application binary interface (ABI) compatibility of the different versions of GlibC [6].

In addition to a build environment, thewtex/centos-build includes supporting tools like CMake, Git, and Apache Subversion (SVN).

slicer/slicer-base

This serves as the base image for slicer/slicer-

dependencies.

slicer/slicer-dependencies

This image contains all the dependencies necessary to build 3D Slicer itself. These dependencies include the Insight Segmentation and Registration Toolkit (ITK), the Visualization Toolkit (VTK), the Common Toolkit (CTK), the Digital Imaging and Communications in Medicine Toolkit (DCMTK), and Qt.

slicer/slicer-build

This image contains both 3D Slicer and the depen-dencies that test a 3D Slicer extension. An example, SlicerITKUltrasound, is available at https://github.com/KitwareMedical/SlicerITKUltrasound.

The Build of a Pull RequestThe build of a pull request begins when the proposed pull request triggers CircleCI to read the configuration file (circle.yml) from the 3D Slicer code base. The file instructs CircleCI to only build the core of 3D Slicer, not its dependencies. If CircleCI detects an update to the 3D Slicer dependencies, it aborts the build, which indicates the need to manually generate a new slicer/slicer- dependencies image and publish it on DockerHub.

Each proposed pull request automatically merges with the master branch in a temporary repository. The Docker image completes the associated build in under an hour and a half. The below schema illustrates the overall improved process.

CDash

Results Feedback on

Github

circle.yml

Dockerfile ctest \-S .cmake

.log files

3D Slicer builds and tests a pull request

through continuous integration.

9

IMPROVEMENT 2 To follow up on Improvement 1 and to consolidate continu-ous integration, the 3D Slicer development team added a testing process that follows a pull request. The tests verify that everything builds correctly for each pull request. As part of the process, CDash stores metadata about the build time. It also stores test information from the commit that triggered the testing process. More information on the CircleCI features that link with GitHub are available at https://circleci.com/docs/environment-variables.

The Use of CircleCI and Docker to Continuously Run 3D Slicer TestsIn order to make the testing process work, the 3D Slicer development team built a new Docker image, thewtex/opengl:centos, which it based on Centos 5. The Docker image provides the X11 window display that many tests require. The following section takes a closer look at this new Docker image.

OpenGL Docker ImageAs previously mentioned, the team based the OpenGL Docker image on thewtex/opengl:centos, which draws inspiration from thewtex/opengl:debian. When a con-tainer that stems from thewtex/opengl:centos launches, it runs a single process [7]. The container runs supervisord as the Dockerfile command [8] to collect failed processes (process identifier reaping) and simultaneously launch mul-tiple commands such as graphical_app [9], vnc [10], and Xdummy. These commands display windows from tests. The orchestrated X window system provides a graphical context to run the tests. Virtual Network Computing (VNC) provides an interface to the system for debugging.

The below schema summarizes the testing process.

CDash

A pull request triggers the execution

of circle.yml.

The thewtex/opengl based container runs.

supervisord runs through a command from the

Dockerfile.

The dockerfile contains ENV APP, which runs

CTest.

graphical_app, vnc, and

Xdummy run.

The results get submitted

to the dashboard.

The testing process continues with Docker.

The first step to create a Docker image is to set up a Dockerfile that begins with FROM thewtex/opengl:centos (or

:debian). After the container generates, the Dockerfile launches supervisord. Once supervisord launches, it

The localhost displays the OpenGL Docker image.

10

deals with graphical_app, which calls the application envi-ronment variable. The Dockerfile must specify this variable using ENV APP "what_you_want_to_launch."

Now, each time the image runs, the run.sh script from the thewtex/opengl repository configures and creates the container. (The script sets the VNC localhost, removes the container when the application is done, and displays prompts from the container.) For further information, please take a look at the README file https://github.com/thewtex/docker-opengl/blob/centos/README.rst.

FUTURE WORKThe 3D Slicer development team seeks to improve the inte-gration of 3D Slicer with VNC and to increase testing speed by leveraging additional CircleCI containers. Please visit the Kitware blog at https://blog.kitware.com to remain updated.

For those interested in integrating 3D Slicer or its testing framework with products and processes, Kitware offers con-sulting and support services. To get started, please contact kitware@kitware.com.

DOCKER TIPThe team noticed that Docker can burn free space disk storage. During local tests on a machine, Docker saves all of the exited containers, mounted volumes, and images that it builds. To save space, the team recommends deleting useless image containers and volumes by running the following:

# remove exited containers:

docker ps --filter status=dead --filter

status=exited -aq | xargs -r docker rm -v

# remove unused images:

docker images --no-trunc | grep '<none>' | awk '{

print $3 }' | xargs -r docker rmi

# remove unused volumes:

docker volume ls -qf dangling=true | xargs -r docker

volume rm

Note that the presence of the VOLUME command in a Dockerfile creates volumes.

REFERENCES[1] Legarreta, John Haitz, and Matt McCormick. “Why should

we spend time writing tests?” Kitware blog, November 21, 2016. https://blog.kitware.com/why-should-we-spend-time-writing-tests.

[2] “Documentation-Rons-Rules-For-Tools.” https://www.slicer.org/wiki/Documentation-Rons-Rules-For-Tools.

[3] Wikipedia. “Continuous integration.” https://en.wikipedia.org/wiki/Continuous_integration.

[4] Hoffman, Bill, Libby Rose, Michael Grauer, and Patrick Reynolds. “Enhancing Software Quality with CI in the Cloud.” Kitware Blog, November 22, 2016. https://blog.kitware.com/enhancing-software-quality-with-ci-in-the-cloud.

[5] Kitware, Inc. “CDash.” http://www.cdash.org.[6] Ponomarenko, Andrey. “ABI Tracker (glibc).” Last modified

December 19, 2016. https://abi-laboratory.pro/tracker/time-line/glibc.

[7] Docker Inc. “Use Supervisor with Docker.” https://docs.docker.com/engine/admin/using_supervisord.

[8] Agendaless Consulting and Contributors. “Supervisor: A Process Control System.” Last modified December 20, 2016. http://supervisord.org.

[9] GitHub, Inc. “thewtex/docker-opengl.” Last modified December 14, 2016. https://github.com/thewtex/docker-opengl/blob/centos/usr/bin/graphical-app-launcher.py.

[10] Wikipedia. “Virtual Network Computing.” Last modified October 17, 2016. https://en.wikipedia.org/wiki/Virtual_Network_Computing.

Mayeul Chassagnard is a research and devel-opment intern at Kitware. He studies computer science, mathematics, electronics, and signal processing at École Supérieure de Chimie Physique Électronique de Lyon.

Jean-Christophe Fillion-Robin is a technical expert and the lead developer of 3D Slicer at Kitware. He is also the lead developer of 3D Slicer for the NA-MIC community. As such, he developed the infrastructure for 3D Slicer extensions.

11

The algorithmic foundation for the SlicerITKUltrasound extension modules [2] is an ITK module, called ITKUltrasound [3]. This module gets built during the extension build process to easily extend the implementation of ITK in 3D Slicer. As an ITK module, ITKUltrasound can easily find use in other contexts outside of 3D Slicer.

Scan conversion resamples processed ultrasound data from its natural transducer sampling geometry onto a uniform grid for visualization and further analysis. Scan conversion is fundamental to all ultrasound imaging modalities, and it must be fast for real-time imaging. First, this article describes the transducer probe geometries that 3D Slicer supports along with their parameterizations. Next, the article highlights resampling algorithms (nine in total). Finally, it discusses the trade-offs and behav-ioral differences of the resampling algorithms and their implementations.

GEOMETRIESThe shape of the transducer probe array determines the ultrasound sampling geometry. A curvilinear array, which is common to abdominal imaging, or a phased array, which is common to cardiac imaging, results in the iconic 2D ultra-sound sector image, for example.

3D Slicer modules support three classes of probe geometries. These modules are as follows:

• ScanConvertCurvilinearArray;

• ScanConvertPhasedArray3D; and

• ScanConvertSliceSeries.

ScanConvertCurvilinearArray scan converts ultrasound probes that position elements along a circular arc. This type of probe is common in abdominal imaging. The angular separa-tion between each lateral line, the physical distances between samples along a radial line, and the radius of the arc param-eterizes the geometry. ScanConvertCurvilinearArray scan converts additional datasets in the third dimension as equally spaced orthogonal slices.

ScanConvertCurvilinearArray converts a curvilinear ultrasound probe.

As a medical imaging modality, one of greatest strengths of ultrasound is its ability to inspect the body's condition in real time. For decades, radiologists, physicians, and ultrasonog-raphers have leveraged traditional two-dimensional (2D) brightness-mode (B-mode) ultrasound images to obtain real-time structural information about soft tissue planes. New opportunities to improve patient care come from imaging disease-specific tissue properties in three dimensions. In par-ticular, opportunities exist in identifying clinically significant prostate cancer lesions by generating three-dimensional (3D) acoustic radiation force impulse (ARFI) images of prostate biopsy candidates [1]. ARFI imaging monitors the mechani-cal response of tissue to a high-intensity ultrasound-pushing pulse. The process results in an image that reflects local tissue viscoelasticity. Stiffer regions become associated with cancer, whereas less-stiff regions become associated with normal tissue or benign prostatic hyperplasia.

A 3D ARFI image visualizes structural relationships, enables comparison with images from other modalities like multi-parametric magnetic resonance imaging, and ensures the identification of focal lesions. Yet, new computational chal-lenges arise with novel ultrasound imaging methods that deal with three dimensions. Advanced image formation methods like ARFI require more processing than methods like B-mode, and the additional image dimension adds to the computational complexity.

This article describes how the 3D medical image processing, parallel computing, and algorithmic architectures of the Insight Segmentation and Registration Toolkit (ITK) and the Visualization Toolkit (VTK) became integrated into a 3D Slicer extension for ultrasound scan conversion, called SlicerITKUltrasound.

3D Slicer Extensions Manager installs the SlicerITKUltrasound extension.

3D SLICER SOFTWARE DEVELOPMENT EXTENDS TO INCLUDE CONTINUOUS USER INTERFACE TESTINGMatt McCormick, Will Schroeder (Kitware), Mark Palmeri (Duke University), Stephen Aylward (Kitware)

12

ScanConvertSliceSeries scan converts a B-mode prostate

volume from a mechanically rotated transrectal probe.

When a module scan converts a volume, the volume gets resampled onto an itk::Image geometry. This geometry is rectilinear, and it potentially has anisotropic spacing, a physical offset (an origin), and an orientation. This geometry is also the natural geometry for ultrasound probes that posi-tion elements along a line, e.g., a linear array.

RESAMPLING METHODSThere are three classes of resampling methods. One class, ITK based resampling methods, uses interpolation functions that operate on input samples in the neighborhood of the desired physical output point. The locations of neighborhood input samples pertain to the mapping from output index space to physical space and from physical space to input continuous index space.

The interpolation method sets the number of samples. ITKLinear (the default method) applies trilinear interpo-lation. ITKNearestNeighbor uses the value of the closest input point to determine the output value. ITKGaussian performs multiplication with a finite-domain Gaussian kernel. Finally, ITKWindowedSinc applies Sinc interpolation with a three-sample radius Lanczos window.

Another two classes operate on a representation of the input as a vtkStructuredGrid data structure. Locator methods that utilize cell topology determine input points. One of these classes, VTKProbeFilter, contains a method that produces an output point, which derives from a weighted combination of points in the surrounding cell.

ScanConvertPhasedArray3D scan converts ultrasound probes that position tightly packed elements on a small surface. This type of probe is common in cardiac imaging. When a wave front becomes electrically steered from the surface during the imaging process, it stimulates the trans-ducer elements. The image that results contains a section of a sphere that centers on the probe. The angular separation between each lateral line in the azimuthal direction and the elevational direction, the physical distances between samples along a radial line, and the distance to the first radial sample parameterizes the geometry.

ScanConvertPhasedArray3D converts a phased array ultrasound probe.

ScanConvertSliceSeries scan converts a set of adjacent, non-overlapping 2D slices. Each slice can have either a cur-vilinear array geometry or a linear array geometry. These geometries are common with mechanically swept 2D probes, where the distance and the orientation of the intermediate slices may or may not be uniform. In such cases, the geom-etries of the component slices determine the geometry of the volume.

13

The other class stems from the new VTK point interpolation framework [4]. While the framework can use a fixed number of nearby points, its implementation for this article consid-ers all the points that fall within a fixed physical radius of an output point. An output point derives from a weighted combination of input points, which the kernel type deter-mines. Methods in the class include VTKVoronoiKernel, VTKLinearKernel, VTKShepardKernel, and VTKGaussianKernel. VTKVoronoiKernel uses nearest-neighbor-like interpolation; VTKLinearKernel employs linear averaging; VTKShepardKernel implements 1 / r^2 weighting; and VTKGaussianKernel utilizes Gaussian weighting.

DISCUSSIONModules in the SlicerITKUltrasound extension currently enable scan conversion of commonly encountered 2D and 3D ultrasound probe geometries. The extension applies not only to B-mode imaging but to ARFI, ultrasound spectroscopy, and other imaging modes. The performant parallelism in ITK and VTK enable high-throughput computing on emerging many-core computing architectures.

A number of different resampling methods exists. These methods present trade-offs in speed, interpolation errors, and interpolation characteristics. The default resampling method, ITKLinear, offers a good combination of speed and smoothly varying output. Alternatively, ITKWindowedSinc provides the most accurate interpolation method. The violation of the rectilinear input assumption in ITK based methods, however, results in some interpolation errors.

Certain cases, such as the interpolation of segmentation labels, call for the retention of input values. ITKNearestNeighbor or VTKVoronoiKernel is appropriate in these cases. Moreover, with the application of VTKGaussianKernel and ITKGaussian methods, it becomes possible to simul-taneously smooth the input and perform interpolation. The physical radius-based interpolation domain of VTK point interpolation methods ensures that consistent spatial content determines an output point. A physical radius-based domain only works well when the spacing of input points is roughly uniform throughout the volume. Otherwise, a computationally taxing number of points in the interpola-tion domain may result, or the interpolation domain may contain no points at all.

ACKNOWLEDGEMENTResearch reported in this publication was supported by the National Institute Of Biomedical Imaging and Bioengineering and the National Institute of General Medical Sciences of the National Institutes of Health under award number R01EB021396 and by the National Cancer Institute of the National Institutes of Health under award number R41CA196565. The content is solely the responsibility of the authors and does not necessarily represent the official views of the National Institutes of Health.

REFERENCES[1] Palmeri, Mark, Tyler Glass, Rajan Gupta, Matt McCormick,

Alison Brown, Thomas Polascik, Stephen Rosenzweig, Andrew Buck, and Kathy Nightingale. In 2016 IEEE International Ultrasonics Symposium (IUS). Proceedings of IUS, France, Tours. Institute of Electrical and Electronics Engineers, 2016. http://dx.doi.org/10.1109/ULTSYM.2016.7728618.

[2] “SlicerITKUltrasound.” https://kitwaremedical.github.io/SlicerITKUltrasoundDoc.

[3] KitwareMedical/ITKUltrasound. October 18, 2016. https://github.com/KitwareMedical/ITKUltrasound.

[4] Schroeder, Will. “Point and Smoothed-Particle Hydrodynamics (SPH) Interpolation in VTK” Kitware blog, August 13, 2016. https://blog.kitware.com/point-and-smoothed-particle-hydrodynamics-sph-interpolation-in-vtk.

Matt McCormick, a technical expert at Kitware, is a major contributor to and the current maintainer of ITK. His general inter-ests include image processing and emphasize scientific reproducibility.

Will Schroeder is president and CEO of Kitware. He identifies technology and busi-ness opportunities, and he obtains the necessary support for Kitware to meet these opportunities. Schroeder also provides tech-nical leadership for large open-source

projects such as ITK and VTK.

Mark Palmeri is an associate professor of the practice in biomedical engineering at Duke University. His research interests include acoustic radiation force shear wave speed (SWS), ultrasonic imaging, finite element analysis of soft tissue response to acoustic

radiation force excitation, medical image processing, and medical instrumentation design.

Stephen Aylward is the senior director of operations and the founder of the Kitware office in North Carolina. He helps direct medical research activities at the company. In general, Aylward’s research focuses on vascular image analysis, computer-aided

diagnosis, and intra-operative registration of ultrasound images with pre-operative images. He also works to develop ITK and other open-source toolkits.

14

Intel® Haswell central processing units (CPUs) and almost a four-times increase on next-generation Intel® Xeon Phi™ coprocessor, or ‘Knights Landing’ (KNL), platforms,” said Chuck Atkins, a staff research and development engineer at Kitware who contributes to ParaView, CMake, and Mesa. “The dramatic increase in measured performance made the decision an easy one. As soon as Mesa 13.0.0 became available, we updated our ParaView build processes to incorporate it. We are now actively deploying Mesa 13.0.0 at partner institutions and customer sites.”

Under a new Intel® Parallel Computing Centers project, Kitware and TACC will collaborate to optimize the full code path of ParaView for in situ processing. This important use case directly couples visualization and rendering with simu-lation codes.

“We are thrilled to partner with Kitware and Intel® to advance in situ capabilities for many-core processors,” said Dr. Paul Navrátil, the manager of scalable visualization tech-nologies at TACC. “The Stampede-KNL system at TACC will be the perfect test bed for developing effective strategies that fully utilize the capabilities on upcoming KNL systems like Trinity, Cori, and Stampede 2.”

PARAVIEW ADDS AWARD TO ACCOLADESOn behalf of the ParaView development community, Kitware accepted an HPCwire Editors’ Choice award for "Best HPC Visualization Product or Technology" this year at The International Conference for High Performance Computing, Networking, Storage and Analysis (SC16), in Salt Lake City, Utah. Last year, ParaView won the HPCwire Readers' Choice award in the same category.

Technical Leader Marcus Hanwell, Staff R&D Engineer Chuck

Atkins, and Chief Financial Officer Ken Martin discuss open-source

software at the Kitware booth.

KITWARE AND INTEL® FURTHER MAXIMIZE RENDERING EFFICIENCYKitware and Intel® updated the Visualization Toolkit (VTK) and ParaView as well as OpenSWR and OSPRay to push the Software Defined Visualization initiative. The work builds on efforts by Kitware, Intel®, and the Texas Advanced Computing Center (TACC) to integrate OpenSWR and OSPRay with VTK and ParaView.

“VTK and ParaView offer open-source solutions for analyz-ing and visualizing data, which the OpenSWR and OSPRay renderers enhance,” said David DeMarle, a lead developer of VTK at Kitware. “The combination of the solutions with the renderers provides an especially powerful path toward visualizing extreme-scale scientific problems with massive supercomputers.”

Kitware released ParaView 5.0 in conjunction with The International Conference for High Performance Computing, Networking, Storage and Analysis (SC) in 2015 as the first official release to include OpenSWR and OSPRay. The succes-sor to ParaView 5.0, version 5.1, more tightly coupled OSPRay with ParaView and added the ability for users to quickly swap between rasterizing and ray tracing images with the same type of surface mesh data. Version 5.1 also brought ray tracing to ParaView on Microsoft Windows. At this year’s SC event, Kitware not only demonstrated these advancements, but it discussed new versions of VTK and ParaView.

“I am particularly excited about the OSPRay based volume rendering modes in VTK 7.1 and ParaView 5.2,” DeMarle said. “OSPRay is a lot faster than VTK’s internal software volume renderer, and the fact that surfaces and volumes coexist in the same ray-traced context opens up new pos-sibilities for visual effects. OSPRay now enables volumetric shadows and, more generally, makes volumetric participat-ing media feasible.”

OpenSWR also features state-of-the-art rendering capabili-ties, which initial benchmarks on the Trinity supercomputer at Los Alamos National Laboratory demonstrated earlier this year. The run used only a fraction of the supercomputing machine during the system shakedown period to render scenes up to 1.1 trillion triangles. Since then, Intel® has contributed OpenSWR to the open-source Mesa implemen-tation of the OpenGL standard. In the recently released Mesa 13.0.0, OpenSWR gained significant optimizations.

“When evaluating whether to update to the recent Mesa 13.0.0 release from the 12 series, we measured nearly a two-times increase in rendering performance with OpenSWR on

KITWARE NEWS

15

Kitware acknowledged the efforts of the development community and noted its appreciation of the award in a press release. The company published the press release on its external blog at https://blog.kitware.com/kitware-receives-honor-in-2016-hpcwire-readers-and- editors-choice-awards. In addition to the press release, Kitware posted pictures from its booth at SC16 on its exter-nal blog. In total, twenty team members attended the event. This is the largest number of attendees that Kitware has sent to the conference to date.

KITWARE ENCOURAGES PARTICIPATION IN MEDICAL IMAGING WORKSHOPTo reflect the commitment of Kitware to accelerate the pace of research and development in academia and indus-try, Senior Director of Operations - North Carolina Stephen Aylward helped to create Workshop: Live Demonstrations at the medical imaging conference of the international society for optics and photonics (SPIE Medical Imaging) in 2009. Following this time, he has played a role in organizing the workshop for the conference.

The live demonstrations aim to compliment the podium and poster presentations of the main conference. These presentations feature recent research in medical imaging topics such as image processing, digital pathology, tomogra-phy, computer-aided diagnosis, and ultrasound. From 2009 to 2016, the workshop attracted more than one thousand attendees from academia and industry, who witnessed over one hundred demonstrations on a range of medical imaging advancements from algorithms, to robotic systems, to medical device prototypes.

While the organization of the workshop has passed to new hands, it will continue to host outstanding demonstra-tions. This year, the workshop will take place on Tuesday, February 14, 2017, in Orlando, Florida. Those who plan to attend SPIE Medical Imaging should consider taking part. Instructions on how to present a demonstration or partici-pate as an attendee are available at http://www.kitware.com/ workshops/SPIE_CAD_2017.html.

At the conference, several members of Kitware will showcase their work through activities such as poster presentations, a tutorial, and an oral presentation. The subjects of this work include craniosynostosis, scientific reproducibility, pediatric surgery, biomedical research, and temporomandibular joint osteoarthritis. Kitware has posted additional details at https://blog.kitware.com/events/spie-medical-imaging-2017.

DONATIONS RISE FOR TOYS FOR TOTS Kitware participated in the Toys For Tots program at its Clifton Park, New York, and Carrboro, North Carolina, offices. The company has participated in the program for numer-ous years. As it did in 2015, Kitware increased its number of donations and exceeded its goal. The company aimed to collect 80 toys this year in New York. It collected close to 100 toys in this location and around 25 toys in North Carolina.

Accounting Specialist Kimberly O'Leary (right) and Office Manager

Tami Grasso (left) present toys to a member of Clifton Park &

Halfmoon Emergency Corps (center), who helped collect donations.

NEW MEMBERS JOIN TEAMKitware hired the following team members. The company introduced these members on Facebook and published their bios on its website at http://www.kitware.com/company/team_alphabetical.html.

Sam PetrocelliPetrocelli joined the computer vision team as an R&D engi-neer. His skills involve stereo thermal imaging, machine learning, point cloud processing, and visualization.

Shusil DangiDangi began an internship in medical computing. He cur-rently studies imaging science at Rochester Institute of Technology for his doctoral degree.

John MoellerMoeller added expertise in developing algorithms for machine learning, deep learning, and computational geom-etry to the computer vision team. He participated in the doctoral forum at the 2016 Society for Industrial and Applied Mathematics International Conference on Data Mining.

Sam HorvathHorvath brought experience in optical coherence tomogra-phy, laser and camera optics, and stereo vision to the medical computing team. She completed her doctoral degree in robotics in September 2016 at Carnegie Mellon University, where she also received her Master of Science.

Jeff HallHall embarked on his role as the director of human resources. He holds a Bachelor of Arts in Psychology from the University of Rochester and an MBA from Empire State College.

Louise WeilerWeiler filled the position of annotation specialist on the com-puter vision team. For a former engagement, she developed an application to track student grades, as they progressed through a two-year training program.

16

Contributors: Lisa Avila, Stephen Aylward, Mayeul Chassagnard, Jean M. Favre, Jean-Christophe Fillion-Robin, Matt McCormick, Mark Palmeri, Will Schroeder, Juri Steiner, and Mathieu Westphal

Graphic Design: Steve Jordan

Editor: Sandy McKenzie

This work is licensed under an Attribution 4.0 International (CC BY 4.0) License.

Kitware, ParaView, CMake, KiwiViewer, and VolView are registered trademarks of Kitware, Inc. All other trademarks are property of their respective owners.

In addition to providing readers with updates on Kitware product development and news pertinent to the open source community, the "Kitware Source" delivers basic information on recent releases, upcoming changes, and technical articles related to Kitware open-source projects.

For an up-to-date list of Kitware projects and to learn about areas into which the company is expanding, please visit the open source pages on the website at http://www.kitware.com/opensource/provensolutions.html.

A digital version of the "Kitware Source" is available in a blog format at http://www.kitware.com/source.

Kitware would like to encourage members of its active developer community to contribute to the "Kitware Source." Contributions may include a technical article that describes an enhancement made to a Kitware open-source project or successes/lessons learned via developing a product built on one or more Kitware open-source projects. The "Kitware Source" is published by Kitware, Inc., Clifton Park, New York.

Kellie CoronaCorona started as an annotation specialist in Clifton Park, New York. Prior to joining Kitware, Corona worked as a research assistant at the University of North Carolina at Chapel Hill, where she completed her doctoral degree in Physics in May 2016.

Kimberly O’Leary O’Leary joined Kitware as an accounting specialist. In previ-ous roles, she completed financial reviews, performed profit analyses, managed client contracts, and coordinated invoices and payroll.

Deepak SharmaSharma started an internship in computer vision. He studies computer science at the University of Rochester, where he works as a student lab instructor.

Aimee NúñezNúñez became a member of the computer vision team at Kitware. She works at the company headquarters as an annotation specialist.

Bryon BeanBean took on a position in software development for an internal finance system. In addition to experience in the creation of mobile and web applications, he brought skills in graphic design to Kitware.

Ameya ShringiShringi commenced an internship at the company headquar-ters in pursuit of his Master of Science. He attends Rochester Institute of Technology, and he has completed coursework in machine learning and parallel programming, among other areas of computer science.

Kitware continues to seek talented, motivated, and creative individuals to develop and deliver cutting-edge software products and services. Team members enjoy an award-winning work environment that empowers them to pursue their passions and perform meaningful work with impact. In addition to a stimulating environment, Kitware pro-vides comprehensive benefits that include flexible hours; a computer hardware budget; health, vision, dental, and life insurance; short- and long-term disability insurance; services for immigration and visa processing; tuition reim-bursement; a relocation bonus; and generous compensation.

Kitware also offers internships to current college stu-dents. Internships provide students with opportunities to gain training and hands-on experience, as they work with leaders in their fields on cutting-edge problems. Kitware has posted additional information on open jobs and internships on its employment website. Those who want to learn more can visit http://jobs.kitware.com/ opportunities.html.