Issue 24 •

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

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

ParaView Catalyst Computes Particle Paths In Situ ................ 3

New ITK-SNAP Features Improve Segmentation ..................... 5

Resonant Lab Extends Data Visualization to the Masses........ 9

Kitware News ............................................................................ 12

RELEASE CYCLE FOR VTK 7.1 INITIATESThe Visualization Toolkit (VTK) development team began the release cycle for version 7.1. The team plans to push the final release in November 2016 and showcase it at The International Conference for High Performance Computing, Networking, Storage and Analysis (SC16).

Developments for version 7.1 include two new modules that provide support for Oculus Rift and HTC Vive virtual reality devices. These modules open new doors for interactive data exploration, which the Kitware blog discusses at https://blog.kitware.com/taking-paraview-into-virtual-reality.

Other enhancements involve zero-copy arrays, new algo-rithms that quickly process point clouds via symmetric multiprocessing (SMP) threading, and volume rendering. In particular, enhancements allow VTK to better render shadow-casting volumes via OSPRay. Enhancements also bring back by popular demand support for rendering on screen (GLX) and off screen (OSMesa) in the same build of VTK and Mesa.

VTK renders volumes that cast shadows with OSPRay.

Beyond rendering, the 7.1 release cycle expands time stamp counters in VTK, which go from 32 bits to 64 bits on Windows. This change allows applications to run for more

TABLE OF CONTENTS RECENT RELEASES

Issue 39 • October 2016

This fall, many of our team members have hit the road to travel to conferences, workshops, and meetings. Earlier in October, we made our way to Athens, Greece, for the 19th International Conference on Medical Computing & Computer Assisted Intervention (MICCAI). Again this year, Senior Director of Operations-North Carolina Stephen Aylward helped to coordinate the MICCAI Young Scientist Publication Impact Award, which we sponsored to recognize the first author on a MICCAI paper that has demonstrated influence through citations and other benchmarks.

In November, we will participate in The International Conference for High Performance Computing, Networking, Storage and Analysis (SC16). At the conference, we will emphasize in situ computation and other topics that relate to scientific visualization. We will hold presentations on these topics at our booth (#3437) throughout the SC16 exhibition, which will take place from November 14 to November 17, 2016. To learn about our various conference activities, please read the event listing on our external blog at https://blog.kitware.com/events/supercomputing-2016. Come see us at SC16 for special giveaways!

EDITOR'S NOTE

2

than a few hours without crashing due to overflow, when they face frequent state changes.

The release cycle also significantly modernizes the source code to make VTK more palatable to new developers. The modernization removes the remaining BTX and ETX wrapper exclusion markers, updates the indentation style, and replaces the non-standard documentation markup with mainstream Doxygen markup.

In preparation for VTK 8.0, which will require C++11, VTK now uses VTK_OVERRIDE, VTK_DELETE_FUNCTION, and VTK_FINAL macros to support the features of the newer C++ syntax. To download the latest in VTK, please see http://www.vtk.org/download.

PARAVIEW BEGINS RELEASE CYCLE FOR 5.2The ParaView development team has started the release process for version 5.2. The latest release candidate includes two new rendering techniques. The first technique is Fast approXimate Anti-Aliasing (FXAA). FXAA smooths jagged edges on lines and polygons in final images. The second technique is hidden line removal. With this technique, ParaView can render wireframes in a manner that shows the topology of an object but does not show the background wireframe surfaces.

ParaView renders a scene without FXAA and hidden line removal.

ParaView renders a scene with FXAA and hidden line removal.

The latest 5.2 release candidate comes with several other new and exciting features such as a ruler that measures dis-tances in a scene. The release candidate also offers the ability to reload data files without reopening them and further improves rendering performance for composite datasets.

The development team expects to make the final release in November 2016. Moving forward, the team will implement a timely release cycle, which includes two planned releases each year. For more information on ParaView, please go to http://www.paraview.org.

CMAKE SETS SIGHTS ON 3.7 RELEASEThe CMake development announced updates for the 3.7 release. These updates allow CMake to use simple toolchain files to cross compile on the Android operating system. Additional updates allow the source file signature for the try_compile() command to honor configuration-specific flags in test projects. Previously, the source file only recog-nized default flags.

The 3.7 release effort provides new Boolean comparison operations for the if() command. The effort also adds conditional support for Fortran to the Ninja generator. This support comes into play when the generator uses a Ninja tool that has the features necessary to utilize Fortran. In terms of specific CMake components, the effort improves CTest and CPack. In particular, the effort supplies CTest with test properties that support test fixtures.

To follow progress on the release cycle, which the develop-ment team expects to wrap up in November 2016, please read the related posts on the Kitware blog at https://blog.kitware.com. To download CMake, please refer to https://cmake.org.

PROJECTS CONSOLIDATE IN KWIVERKitware released a new version of the Kitware Image and Video Exploitation and Retrieval (KWIVER) toolkit. The open-source toolkit contains software tools that perform image and video analysis.

The development effort for the release refactored the toolkit to combine several existing software components. In particu-lar, the refactor integrated three projects into one repository: Vital, Arrows, and Sprokit. Vital provides support for logging and managing configuration files. Vital also offers support for core data structures and abstract algorithm application programming interfaces (APIs). Arrows delivers a collection of plug-ins that implements the APIs that Vital defines, and Sprokit supplies the architecture for combining the plug-ins into a pipeline for processing video or other streaming data.

As a result of the refactor, KWIVER hosts more features. It also presents a simplified process for building applications against its packages. This simplified process eliminates the need to find compatible versions of separate repositories. For more information on KWIVER and its components, please visit http://www.kwiver.org.

3

PARAVIEW CATALYST COMPUTES PARTICLE PATHS IN SITU

Andrew Bauer (Kitware), Andrew Wissink, Mark Potsdam, Buvana Jayaraman (AMRDEC)

Rotorcraft, such as helicopters, exhibit cyclic behavior as they fly in their respective wakes. This behavior makes it difficult for analysts to evaluate results from computational fluid dynamics (CFD) simulations. Other factors that make rotorcraft difficult to evaluate include unsteady, vortex-dominated flow; reverse flow; compressibility; yawed flow; and flow separation. The complex flow fields of rotorcraft simulations hinder analysts as they attempt to set accurate initial conditions. In practice, several rotor blade revolutions must occur before the undesired transients that result from the poor initial conditions attenuate out. Due to all of the above complicating factors, the simulations often take long to run.

Particle paths, or path lines, track particles in fluid flows. The paths provide critical information to help analysts understand CFD simulation results. In particular, particle paths allow analysts to better comprehend unsteady flow. Analysts have used particle paths to assess model configu-rations and flight maneuvers for the HELIcopter Overset Simulations (HELIOS) code. This code stemmed from the Computational Research and Engineering Acquisition Tools and Environments – Air Vehicles (CREATE™-AV) effort of the Department of Defense High Performance Computing Modernization Program (HPCMP).

Although particle paths have offered analysts important insights, the post hoc computation of these paths has histori-cally required significant resources. The computation calls for analysts to save large numbers of files to obtain appropriate fidelity in the output results. Since the input and output of files have often constituted the slowest parts of simulation runs, analysts have rarely saved simulation results for every time step, even on moderately sized problems.

To make matters worse, post hoc computation also calls for analysts to post-process results. To do so, analysts must load files back in from disk. While analysts have found it prob-lematic to load and save data on workstations, they have experienced even more issues on high-performance comput-ing (HPC) machines, as the compute to input/output (I/O) disparity increases.

To reduce file I/O, analysts have utilized in situ computation. In situ computation occurs during simulation runs, so it efficiently uses computer resources. With in situ computation, ana-lysts can access visualization and analysis results from all time steps, and they can produce desired informa-tion, potentially without performing any additional post-processing. (Bauer et al. [1] discuss in situ computation.)

To compute particle paths in situ, analysts can employ ParaView Catalyst [2]. ParaView Catalyst uses ParaView as a library. It allows analysts to decide which ParaView functionalities they want to insert directly into parallel simu-lation codes such as HELIOS. Thus, ParaView Catalyst offers unprecedented production-quality capabilities, and it saves significant computational resources.

ParaView Catalyst did not always contain all of the neces-sary functionalities to compute particle paths in situ, so the development team worked to add them. This article high-lights these functionalities.

IN SITU COMPUTATION WITH PARAVIEW CATALYSTTo enable ParaView Catalyst to compute particle paths in situ, the development team needed to add four key func-tionalities to ParaView. These functionalities specify the initial time step for particle path computation, clear the particle history, cache the previous time step, and restart the simulations, respectively.

The team did not, however, want to complicate the compu-tation process in the ParaView graphical user interface (GUI). Accordingly, the team added a special class to ParaView, vtkInSituPParticlePathFilter. The following sections detail the use of the class to compute particle paths in situ.

Specifying the Initial Time Step for Particle Path ComputationAs mentioned earlier, rotorcraft simulations like HELIOS can take a non-trivial amount of time to attenuate out poor initial conditions. Analysts need a particle path filter to inject particles into simulation flows after a certain number of time steps to avoid the computation of useless and pos-sibly confusing results. For post hoc analysis, this means that the filter must process data from files with time steps of interest. For in situ analysis, however, the respective filter must inject particle paths and advect them only after a certain time step. The SetFirstTimeStep() method in the vtkInSituPParticlePathFilter class specifies this time step.

Clearing the Particle HistoryIn post-processing particle paths in ParaView, the file I/O cost dwarfs the actual computation cost. Accordingly, the particle path filter outputs the full time-dependent history for each particle for subsequent analysis and visualization. When computing particle paths in situ, file I/O does not pose an issue, since the resident memory already contains all of the information necessary to compute the paths.

4

With in situ computation, the difficulty stems from high temporal fidelity, as in situ analysis considers every time step, while post hoc analysis typically considers every tenth-or-greater time step. Storing the full history of each particle path can become memory-intensive rather quickly, especially for long-running simulations that contain many injected particles. Accordingly, the SetClearCache() method in the vtkInSituPParticlePathFilter class only stores the current locations of the particle paths in memory.

Caching the Previous Time StepWhen ParaView post-processes results, the particle path filter and the pipeline mechanics control the iteration through time steps. When ParaView Catalyst post-processes results, the particle path filter normally only has access to the current time step. In order to compute the time advance of each particle, ParaView Catalyst must cache the previous time step. The vtkInSituPParticlePathFilter class automatically stores this cache.

Restarting the SimulationsHELIOS simulations typically run for several or more days. To extend beyond the limits of HPC queues, ana-lysts will periodically restart their simulations from previously computed time steps. To make the par-ticle path results from in situ computation useful, the vtkInSituPParticlePathFilter class must evaluate the results independent of whether or not the analysts restarted the simulations.

In order to restart, simulations must save information about simulation state. Similarly, ParaView Catalyst must save infor-mation about vtkInSituPParticlePathFilter state. When simulations restart, the AddRestartConnection() method in the vtkInSituPParticlePathFilter class uses a reader to load previously saved information about particle state. The vtkInSituPParticlePathFilter class then continues to compute particle paths without any noticeable difference in output.

ParaView Catalyst generates in situ output.

ParaView Catalyst generates in situ output for a subsequent time step.

ParaView Catalyst generates in situ output for a later time step.

RESULTSHELIOS ran with an experimental configuration called Higher-harmonic control Aeroacoustics Rotor Test II (HART-II). Many modelers and code developers find this configuration interesting, as it contains a good validation database. The setup for the simulation included a total of 14,400 time steps on 576 Message Passing Interface (MPI) processes on a Cray XC30 supercomputer. The setup process divided the simula-tion into two separate run stages. Each run stage simulated 7,200 time steps. Both run stages required roughly 38 hours of wall-clock run time.

In situ computations began at time step 720 and included analyses for the particle paths and the rotorcraft geometry. The vtkInSituPParticlePathFilter filter class injected 30 particles at this time step and at every 720th time step that followed. At each time step, the paths of the injected particles updated.

A separate set of in situ operations wrote out the particle path locations and the rotorcraft geometry at every 72 time steps. This means that, through ParaView Catalyst, the simu-lation output results at 191 time steps. The simulation also wrote out the full grid twice (at time steps 0 and 4,320).

5

The total in situ compute time amounted to 54 minutes during the first run stage and 66 minutes during the second run stage. For comparison, the output size of the particle data came to 510 MB (an average of 2.7 MB per output time step), the output size of the rotorcraft geometry came to 7.4 GB (an average of 39 MB per output time step), and the output size of the full data came to 24 GB (an average of 12 GB per output time step). While HELIOS may not classify these as large simulations, they certainly demonstrate the power of in situ computation to reduce the amount of data that analysts must write to disk.

ParaView 5.1.2 contains an example problem that ana-lysts and others can use to compute particle paths in situ. To access the example, go to the “Examples/Catalyst/CxxParticlePathExample” source sub-directory. To watch a video on in situ computation with ParaView Catalyst, visit https://vimeo.com/182893083.

Approved for public release; distribution unlimited.

Review completed by the AMRDEC Public Affairs Office (PR2502, 23 Sept 2016)

REFERENCES[1] Kitware, Inc. “ParaView Catalyst for In situ Analysis.”

http://www.paraview.org/in-situ.[2] Bauer, Andrew, Hasan Abbasi, James Ahrens, Hank Childs,

Berk Geveci, Scott Klasky, Kenneth Moreland, Patrick O'Leary, Venkat Vishwanath, Brad Whitlock, and E. Wes Bethel. “In Situ Methods, Infrastructures, and Applications on High Performance Computing Platforms.” Computer Graphics Forum 35 (2016): 577–597.

Andrew Bauer is a staff research and devel-opment engineer on the scientific computing team at Kitware. He primarily works on enabling tools and technologies for HPC simulations.

Andrew Wissink is a researcher in the rotor-craft computational aeromechanics group at the U.S. Army Aviation Development Directorate of Aviation and Missile Research, Development, and Engineering Center (AMRDEC). He is also the lead

developer of HELIOS.

Mark Potsdam is a researcher in the rotor-craft computational aeromechanics group at the U.S. Army Aviation Development Directorate of AMRDEC. He specializes in complex, multidisciplinary rotorcraft simula-tions that use HPC.

Buvana Jayaraman is a part of the HELIOS development team. She is responsible for the development of the HELIOS GUI and for the validation of HELIOS.

NEW ITK-SNAP FEATURES IMPROVE SEGMENTATIONDženan Zukic, Matthew McCormick, Jared Vicory (Kitware), Guido Gerig (New York University), Paul Yushkevich (University of Pennsylvania)

ITK-SNAP [1] is a software application that segments struc-tures in three-dimensional (3D) biomedical images. The application is free, open source, and multiplatform. Over the last several years, the application has undergone signifi-cant refactoring and expansion. It now includes a modern, Qt based graphical user interface; extensive support for segmenting multi-modality and multi-parametric imaging datasets; and more powerful tools for performing semi-automatic segmentation. ITK-SNAP also features improved performance and scalability [2].

This article briefly describes two additions to ITK-SNAP. The first addition is run-length encoding (RLE), which compresses label maps for storing image segmentations. The second addition is a morphological contour interpolation filter, which Albu et al. first proposed [3].

RLEIMAGEWhen many adjacent pixels share the same value, as is almost always the case with label maps that represent organ segmentations, RLE can significantly save storage. Instead of keeping a line of pixels as “11111222200004555,” RLE stores the pixels as “5×1 4×2 4×0 1×4 3×5.” This reduces memory usage from 13 numbers to 10 numbers. For 3D images with millions of voxels, the savings prove far more significant.

RLE compression reduces the brain parcel to 9.73

percent of the original size.

6

To implement an RLE data structure for arbitrary dimension-ality, ITK-SNAP relies on an existing Insight Segmentation and Registration Toolkit (ITK) class, itk::Image. ITK-SNAP implements an RLEImage of n dimensions as an itk::Image with n-1 dimensions through the following run-length lines:

typedef std::pair<TCounter, TPixel> RLSegment;

typedef std::vector<RLSegment> RLLine;

typedef itk::Image<RLLine, VDimension-1> RLEImage;

For this image class to offer utility, it has to provide the access methods that ITK normally uses for the itk::Image class. These access methods include Get/Set operators as well as const iterators and writable iterators. With these operators and iterators, RLEImage can serve as a drop-in replacement for itk::Image, as long as the user code does not assume a linear pixel layout, which it frequently does.

Furthermore, to display slices, ITK-SNAP needs to extract them. Slicing serves as the most frequently used operation that involves label maps. With the release of ITK-SNAP 3.4, the switch to RLEImage only mildly affected slicing per-formance. In tests, slicing took about the same time with RLEImage and itk::Image. For example, it took 11.7 mil-liseconds to axial slice brain parcels with RLEImage, and it took 10.3 milliseconds to axial slice the same parcels with itk::Image. The worst practical case involves axial slicing a whole body that the watershed algorithm has segmented. In this case, it took 154 milliseconds to slice the body with RLEImage and 79 milliseconds to slice the body with itk::Image.

MORPHOLOGICAL CONTOUR INTERPOLATIONWhile the use of automatic segmentation algorithms has become more popular, the medical computing community continues to measure the performance of the algorithms against a manually created “gold standard” segmentation [1]. Additionally, the community continues to use manual segmentation to train the algorithms and to solve problems for which automatic segmentation is not sufficiently reliable.

Manual segmentation, however, is often a slow and tedious process. An alternative approach to dense manual segmen-tation is to manually segment a sparse number of slices and use interpolation to fill in the gaps. This approach generates fully segmented volumes with much less manual input. The following screenshots demonstrate manual segmentation with the use of two labels on coronal slices.

ITK-SNAP displays example input of hippocampal subfields in

in-vivo T2-weighted magnetic resonance imaging (MRI) scans.

ITK-SNAP shows example output.

Interpolation determines the correspondence between shapes on adjacent segmented slices. To do so, it detects overlaps, aligns the overlapping shapes, generates a transi-tion sequence of one-pixel dilations, and takes the median as the result. Recursion can aid situations in which more than one empty slice separates the original slices. Albu et al. describe the method of interpolation [3]. The method retains some distinctive features and does not suffer from excessive smoothing, unlike most shape-based methods.

The itk::MorphologicalContourInterpolator class implements interpolation. This class contains an image-to-image filter that supports 3D, four-dimensional, and higher-dimensional inputs. ITK-SNAP can restrict the filter to interpolate one label and/or to interpolate along one axis.

7

The below example of interpolation kept every fourth output from the original manually segmented image. The example then used the reduced segmentation as input, and it used the original segmentation as ground truth, against which it measured the interpolated segmentation.

ITK-SNAP interpolates output and overlays it on a synthetic input

with a sparsity of four.

Tests on two images, “c10” and “c2,” with full manual seg-mentations evaluated interpolation performance. The tests left every nth slice to simulate sparse manual segmentation and cleared the rest of the images. Each test used the slices as input to the filter and then compared the output with the original image.

Dice similarity coefficient (DSC), positive predictive value (PPV), and negative predictive value (NPV) plots demonstrate the loss of precision that occurs with increasingly sparse manual segmentations. To calculate PPV and NPV, the tests assumed a background equal in size to the objects.

A plot averages the loss of precision over two images (“c10” and “c2”) and four axes (x, y, z, and x+y+z). The

abscissa of the plot shows segmentation sparsity.

A plot displays the loss of precision for image “c10,” after a test simulates segmentation along the x-axis, the y-axis, and

the z-axis.

A plot demonstrates the loss of precision for image “c10,” after a test simulates segmentation along the x-axis.

A plot shows the loss of precision for image “c10,” after a test simulates segmentation along the y-axis.

8

A plot illustrates the loss of precision for image “c10,” after a test simulates segmentation along the z-axis.

As the resolution was already three times lower along the z-axis, adding sparsity exacerbated the problem. Most errors denote false negatives, which indicate places where the interpolated image presented pixels, but the ground truth did not. Other errors denote false negatives, which indicate places where the ground truth presented pixels, but the interpolated image did not. The below screenshot represents false positives in cyan, yellow, and green, and it portrays false negatives in violet, red, and blue.

ITK-SNAP exhibits interpolation errors.

The test for the above screenshot used the same portion of "c10" that the test for the previous screenshot used.

OPEN SCIENCEThe general public can access the RLEIMage class and the morphological contour interpolation filter as ITK remote modules under the Apache 2.0 license. These remote modules contain source code, unit tests, test data, and docu-mentation. To download the remote modules, please go to the following websites: https://github.com/KitwareMedical/

ITKRLEImage and https://github.com/KitwareMedical/ITKMorphologicalContourInterpolation.

ACKNOWLEDGMENTThe National Institutes of Health grant R01-EB014346, “Continued development and maintenance of the ITK-SNAP 3D image segmentation software,” supported the ITK-SNAP segmentation work.

REFERENCES1. Yushkevich, Paul A., Joseph Piven, Heather Cody Hazlett,

Rachel Gimpel Smith, Sean Ho, James C. Gee, and Guido Gerig. “User-guided 3D active contour segmentation of anatomical structures: Significantly improved efficiency and reliability.” Neuroimage 31(2006): 1116−1128.

2. Yushkevich, Paul A., Yang Gao, and Guido Gerig. "ITK-SNAP: an interactive tool for semi-automatic segmentation of multi-modality biomedical images." In EMBC 2016 Proceedings, 38th Annual International Conference of the IEEE Engineering in Medicine and Biology Society, Orlando, Florida, 2016. New York, New York: Institute of Electrical and Electronics Engineers.

3. Albu, Alexandra Branzan, Trevor Beugeling, and Denis Laurendeau. “A morphology-based approach for interslice interpolation of anatomical slices from volumetric images.” IEEE Transactions on Biomedical Engineering 55(2008): 2022−2038.

Dženan Zukic is a senior research and devel-opment engineer on the medical computing team at Kitware. For his dissertation, he studied the segmentation of vertebral bodies in magnetic resonance images.

Matthew 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.

Jared Vicory is a research and development engineer at Kitware. While working toward his doctoral degree, he developed a method for interpolating sparse contours into a dense 3D surface.

Guido Gerig is an institute professor at the New York University Tandon School of Engineering. His work revolves around image analysis in medicine, engineering, and statistics.

Paul Yushkevich is an associate professor in the department of radiology at the University of Pennsylvania. He develops novel compu-tational methodologies for the analysis of biomedical imaging data.

9

Resonant Lab shows the fields it requires to make an account.

In addition to links to register for or log in to an account, Resonant Lab displays options to create a new project and upload data, start with a visualization, or begin with a dataset from the public library of stan-dard examples. This article explores the “cars” dataset, which contains information about several makes of consumer automobiles across various model years. The dataset includes information that pertains to automobile construction (e.g., weight, number of cylinders, and engine displacement) and performance (e.g., gas mileage, maximum power output, and zero-to-sixty acceleration time).

Resonant Lab opens the “cars” dataset.

After Resonant Lab opens a dataset such as "cars," it dis-plays three main panels: Dataset, Data Matching, and Visualization.

RESONANT LAB EXTENDS DATA VISUALIZATION TO THE MASSES

Libby Rose, Roni Choudhury (Kitware), Alex Bigelow (University of Utah)

In today’s world, data is every-where. Scientific research, financial analysis, and market-ing campaigns produce massive amounts of data. As the data available grows, so too does the possibility that it becomes mis-

understood, which leads to frustration. Any researcher who has had their results misrepresented in the news knows this frustration. The answer lies in data visualization, as it can clearly communicate complex topics.

Web-based, interactive visualization tools aid comprehen-sion and offer hands-on data exploration. While many open-source web-based tools can create different types of visualizations, most call for advanced knowledge of com-puter programming to set up. Further, while developers build many new tools, these tools often remain relatively unknown. They appear complex and do not reach wide audi-ences. Big Data poses big problems as well. Imperfect and incomplete datasets, for instance, become challenging to represent. In addition, the analysis of these datasets requires distributed databases, statistical sampling methods, and new algorithms.

To solve these problems, Kitware has teamed with the XDATA program of the Defense Advanced Research Projects Agency (DARPA) to create Resonant, an open-source platform for data management, analytics, and visualization. Resonant has several components, which come together in Resonant Lab. This easy-to-use, web-based tool provides a point-and-click interface that removes the barriers to entry for data visualization. The tool applies to a wide variety of fields such as healthcare and climate science, among others.

Resonant Lab comes out-of-the-box with commonly used visualization types like scatter plot, histogram, and line chart. The tool makes it easy to switch between visualiza-tions to answer many different questions with the same dataset. To highlight the ability of Resonant Lab to illustrate trends such as fuel economy, this article provides an in-depth look at how to create a visualization with example data.

USING RESONANT LABKitware has made it easy to try out Resonant Lab through https://resonantlab.kitware.com. Once Resonant Lab opens on the website, it provides links to register for or log in to an account. While the use of the tool does not necessitate an account, an account allows Resonant Lab to upload files from a computer.

10

In the Dataset panel, Resonant Lab can expand each com-ponent of the “cars” dataset to display a histogram of its content and provide an inside look into the data.

The “economy (mpg)” component expands to reveal a histogram.

In the Visualization panel, Resonant Lab requires the selec-tion of a visualization type. Once Resonant Lab receives this selection, it needs instructions on which visual attributes it should map to the components of the dataset. Mapping involves clicking on a component such as “economy (mpg)” and then clicking on one or more of the available attributes. To simplify the mapping process, Resonant Lab highlights the available attributes for a given component in light green.

The type of visualization determines the available attri-butes. For example, scatter plot has the following attributes: "x-axis," "y-axis," "size," "shape," "color," and "labels." The data type further limits these choices. Resonant Lab can only map "x-axis" and "y-axis," for instance, to data types with numeric values. For the “cars” dataset, “economy (mpg)” contains an “(empty string)” value. Accordingly, Resonant Lab automatically detects the data type for “economy (mpg)” as text. This data type prevents Resonant Lab from mapping “economy (mpg)” to "x-axis" or "y-axis." Since cars measure fuel economy in mpg, however, "economy (mpg)" should instead use the "Number" data type. Clicking on the data type indicator to override “Autodetect” with “Number” treats the missing, empty string data as “not a number” values and the known data as numeric values. With this override, Resonant Lab can successfully map “economy (mpg)” to an axis.

Mapping “year” to "x-axis," “economy (mpg)” to "y-axis," “0–60 mph (s)” to "color," and “cylinders” to "size" creates a scatter plot of the “cars” dataset that shows a clear trend of how fuel economy has changed over time. Resonant Lab

Resonant Laboratory tailors the Dataset, Data Matching, and Visualization panels to the “cars” dataset.

11

can further drill down into the details of the dataset. After mapping "economy (mpg)" to "hover" and hovering over a data point, for example, Resonant Lab can display the make and the model of the car for that point.

The above scatter plot may help a salesman who wants to convince a potential buyer that a new fuel-efficient car is the way to go. Nevertheless, the scatter plot may not do much for the salesman, if the potential buyer wants to compare features to buy a used car. In this situation, the salesman may want to switch to another visualization type. Resonant Lab makes it easy to do so. Clicking on the "switch visualization" icon ( ) in the Visualization panel brings up the option to select a different type of visualization. Resonant Lab auto-matically loads the mapping attributes that correspond to the new visualization.

A LineUp visualization can better compare features of used cars with dynamic, interactive, weighted comparisons. Instead of axes, a LineUp visualization sorts data in columns by relative importance. Wider columns denote heavier weights than thinner columns. For the "cars" dataset, LineUp weights the"economy (mpg)" column the heaviest.

SUITING NEEDS IN DIFFERENT INDUSTRIESBeyond LineUp, Kitware has added visualization types such as UpSet to Resonant Lab. An UpSet visualization displays a matrix of dataset intersections to quantitatively evaluate how datasets relate to one another. Kitware can help to further customize Resonant Lab to meet industry-specific needs in areas such as natural language processing, geo-

spatial and scientific visualization, and software process. To tailor Resonant Lab to specific workflows, Kitware offers consulting and support services. To obtain information on these services, please email kitware@kitware.com.

The website for the Resonant platform offers additional information on Resonant Lab. It also contains overviews of the various components of the Resonant platform. To learn more about the Resonant Lab application and the Resonant platform, please visit http://resonant.kitware.com.

Libby Rose is a business development representative at Kitware. She received a B.S. in Computer Science from Rensselaer Polytechnic Institute and an MBA from The College of Saint Rose. She has prior experi-ence as an engineer and as a consultant.

Roni Choudhury is a senior research and development engineer at Kitware. His work has incorporated ray tracing, information visualization, and simulation.

Alex Bigelow is a student at the University of Utah who is pursuing a doctoral degree in computing. He works as a research assistant at the Scientific Computing and Imaging (SCI) Institute at the university.

A scatter plot represents fuel economy over time.

12

FIRST HACKFEST UPGRADES GIRDER In August, Kitware held the first Girder hackfest to enhance the open-source, web-based platform for data management. Over 20 participants attended the all-day hackfest, during which they made a variety of improvements to Girder.

For starters, participants continued to work on a major over-haul of the front-end build infrastructure. Sébastien Barré led this effort, which transitioned the build system for the Girder web client to use Webpack. Webpack allows Girder to ship modular front-end libraries that different applications can easily reuse. Participants also continued to work on a plug-in for a robust Digital Imaging and Communications in Medicine (DICOM) viewer, which integrates directly with the Girder web client.

Participants in Clifton Park, New York, work to make improvements to Girder during the hackfest.

In addition to their work on existing efforts, participants added several new features to Girder. A new external application template provides a starting point for building custom front-end applications that Girder backs. Another new feature offers administrators the ability to look up files that a specific assetstore manages. The participants also created a modularized Ansible role to easily deploy Girder; a centralized mechanism to manage URL routes in a Girder installation; and a plug-in, slicer_cli, to integrate Girder and Girder Worker with Slicer Execution Model.

In other developments, participants improved data schema validation capabilities on the Girder backend via JavaScript Object Notation (JSON) Schema. They also enhanced the

KITWARE NEWS

Midas 3 to Girder migration script, and they migrated testing data for the Insight Segmentation and Registration Toolkit (ITK) from https://midas3.kitware.com to https://data.kitware.com.

To try out the upgrades made during the hackfest, please download the latest version of Girder at https://github.com/girder/girder.

KITWARE CELEBRATES DECADE IN CARRBOROTen years ago, Stephen Aylward and Julien Jomier opened the first Carrboro, North Carolina, office location for Kitware. Currently, Kitware employs over 30 team members in Carrboro. To accommodate growth, Kitware recently ren-ovated a 10,000 square-foot office space. The space houses an open floor plan with large windows, which overlook the picnic tables and greenery that surround the historic Carr Mill Mall. The renovated space neighbors a yoga studio in downtown Carrboro, where team members can take free classes on Fridays.

Brad Davis, Stephen Aylward, and Deb Howell receive recognition at a celebration in Carrboro, North Carolina.

The office is also within walking distance of the University of North Carolina at Chapel Hill (UNC), where Aylward and Jomier held positions as faculty members in the depart-ment of radiology. While at UNC, they worked closely with Kitware CEO Will Schroeder and with Kitware Vice President and Chief Technical Officer Bill Hoffman on the original development of the Insight Segmentation and Registration Toolkit (ITK). The impact of Kitware and its open-source efforts (such as ITK, CMake, and the Visualization toolkit) in medical image analysis and scientific computing motivated Aylward and Jomier to leave their academic positions and

13

form the Carrboro office. Today, the office continues to have strong ties with its academic roots and with the high-quality students and faculty at UNC.

The employees that Kitware has hired in Carrboro have greatly contributed to the success of the office. The first two employees to join Aylward and Jomier have become leaders at the company: Brad Davis, assistant director of business development, and Patrick Reynolds, technical leader in sci-entific computing. In 2010, the team hired Deb Howell as an office manager, who has helped to shepherd the distin-guished culture at Kitware. The office has also enticed some talent from the company headquarters in New York. Andinet Enquobahrie, assistant director of medical computing, made the move down south in 2009, and Ken Martin, chairman and chief financial officer, moved to Carrboro in 2015.

Since March 2013, the Carrboro office has increased its number of team members by almost 50 percent. This growth has helped it once again secure a place on the list of software developers in the “Triangle Business Journal.” While the office expands, it remains focused on what makes Kitware great: outstanding research and development, combined with amazing software mojo. Jean-Christophe Fillion-Robin and the entire National Alliance for Medical Image Computing (NA-MIC) team, for example, have com-pletely redesigned and reinvigorated 3D Slicer; Matthew McCormick has coordinated, facilitated, and ensured the integrity of ITK; and Zach Mullen has guided the develop-ment and adoption of Girder. Thus, although the office once primarily focused on medical computing, it has broadened its expertise to include analytics, scientific visualization, and software processes. The office now serves a range of custom-ers from government agencies such as the National Institutes of Health and the Department of Energy to Fortune 500 companies such as Google and Zimmer Biomet.

Kitware would like to congratulate and express appreciation to all of the employees who have helped its Carrboro office grow and succeed. They have made Kitware an even better place at which to work and have contributed significantly to open-source and scientific computing software. Kitware would also like to recognize the management of the Carr Mill Mall for its support of the office renovation.

KITWARE FUELS PROJECT FOR PLANNING PEDIATRIC SURGERYKitware announced a Phase II award from the National Institutes of Health to help surgeons plan and evaluate treatment for craniosynostosis. Craniosynostosis is a medical condition in which cranial sutures prematurely fuse during prenatal development. The resulting deformations can cause elevated intracranial pressure, brain growth impairment, and developmental deficiency in pediatric patients.

“Surgeons face tough decisions in treating craniosynos-tosis,” said Andinet Enquobahrie, Ph.D., MBA, a principal investigator on the project and the assistant director of

medical computing at Kitware. “While the condition can inflict blindness, decrease motor skills, and reduce cognitive function, treatment options are often invasive and present risks such as blood loss. Currently, methods for planning and evaluating treatment are subjective and fail to adequately account for potential variations in patient anatomy.”

To provide surgeons with an objective and reproducible solu-tion, a team from Kitware and Children’s National Health System is developing an intelligent cranial surgical planning system, known as iCSPlan. Unlike other systems, which base treatment plans on average cranial shapes, iCSPlan measures each patient’s cranium and compares it to over 300 com-puted tomography (CT) scans of crania without synostosis. Based on statistical analysis, iCSPlan determines the ideal cranial shape.

The graphical user interface of iCSPlan delivers real-time mesh modification, surface-based rendering, and

volume visualization capabilities.

“The Phase I proof-of-concept study successfully achieved its aims and provided a solid understanding of the challenges and opportunities of cranial vault remodeling,” said Marius George Linguraru, Ph.D., a principal investigator on the project from the Sheikh Zayed Institute for Pediatric Surgical Innovation at Children’s National. “In the Phase II effort, we will improve iCSPlan and conduct a clinical feasibility study at Children’s National under the supervision of Division Chief, Plastic and Reconstructive Surgery, Gary Rogers, M.D.”

To assist surgeons in evaluating treatment options, iCSPlan generates quantitative and anatomically segmented cranial maps using modules from 3D Slicer. The team will extend iCSPlan to create additional visualizations that will interac-tively guide surgeons in virtually repositioning crania.

“3D Slicer is an open-source medical imaging application and a powerful resource for rapidly prototyping surgical plan-ning software,” Enquobahrie said. “Its flexible architecture has allowed us to create an intuitive interface for iCSPlan.”

The team will enable iCSPlan to complete two additional tasks. The first is to analyze postoperative three-dimensional photography data, the collection of which does not expose patients to harmful radiation. The second is to account for

14

any brain development that occurs in the period between diagnosis and postoperative data collection.

Research reported in this publication was supported by the Eunice Kennedy Shriver National Institute Of Child Health & Human Development of the National Institutes of Health under Award Number R42HD081712. The content is solely the responsibility of the authors and does not represent the official views of the National Institutes of Health.

TEAM MEMBERS DONATE SCHOOL SUPPLIES TO YMCA PROGRAMKitware collected school supplies at its headquarters in Clifton Park, New York, for the Southern Saratoga YMCA Running Start program. The Kitware Gives Back team worked with Kelly Mariano from the Southern Saratoga YMCA, who coordinates the program.

The program helps children from families with financial difficulties. The program aims to give participants back-packs with the supplies they need to start the new school year on the right foot. To identify eligible participants for the program, the Southern Saratoga YMCA works with the Shenendehowa school district.

RESEARCH PROJECT AIMS TO ACCELERATE MULTIPHYSICSKitware has embarked on Phase II of a Department of Energy (DOE) Small Business Innovation Research project to help sci-entists study the multiphysics nature of particle accelerators.

“Scientists use particle accelerators in a wide variety of appli-cations including research in pharmaceuticals, electronic materials and clean energy,” said Bob O’Bara, an assistant director of scientific computing at Kitware and the princi-pal investigator on the project. “While scientists realize the importance of accelerators, they find that modeling accelerator systems raises issues of cost and complexity, as the process involves coupling multiple physics-based simula-tions such as thermal and structural simulations. Scientists currently lack effective computational tools to couple such simulations.”

Physics-based simulations often employ datasets that have several moving pieces such as models, meshes, and informa-tion that describes material properties as well as boundary conditions. Many existing technologies require scientists to manually track these pieces, which can lead to errors. For the DOE project, Kitware is working with collaborators to extend ModelBuilder, an application that automatically tracks data and guides it through the simulation life cycle.

“A major advantage of ModelBuilder is that it provides an intuitive way to set simulation input parameters,” O’Bara said. “ModelBuilder also offers a straightforward user interface, and it integrates with desktop, high-performance computing and cloud-based systems. As a result, scientists can test their designs for particle accelerators in a simple and cost-effective manner.”

O’Bara and his team are currently working to optimize a prototype of ModelBuilder that they created during Phase I of the DOE project. The prototype includes key capabilities for rendering and post-processing data, maintains a modular design and builds on the framework of Computational Model Builder (CMB).

“The CMB framework makes ModelBuilder highly customiz-able,” O’Bara said. “Scientists can seamlessly extend code or add plug-ins. Thus, the framework allows the utility of ModelBuilder to reach far beyond multiphysics to fields such as hydrology and nuclear energy.”

During Phase II, the team looks to add functionality for in situ analysis to ModelBuilder as well as support for work-flow wizards and new visualization pipelines. At the end of the effort, the team will release the developed software as open source.

This material is based upon work supported by the U.S. Department of Energy, Office of Science, Office of Acquisition and Assistance, under Award Number DE‐SC0013884.

This report was prepared as an account of work sponsored by an agency of the United States Government. Neither the United States Government nor any agency thereof, nor any of their employees, makes any warranty, express or implied, or assumes any legal liability or responsibility for the accuracy, completeness, or usefulness of any information, apparatus, product, or process disclosed, or represents that its use would not infringe privately owned rights. Reference herein to any specific commercial product, process, or service by trade name, trademark, manufacturer, or otherwise does not necessarily constitute or imply its endorsement, recom-mendation, or favoring by the United States Government or any agency thereof. The views and opinions of authors expressed herein do not necessarily state or reflect those of the United States Government or any agency thereof.

VTK BOOKS BECOME AVAILABLE FOR DOWNLOADOn the website for the Visualization Toolkit (VTK), Kitware released PDF versions of "The Visualization Toolkit: An Object-Oriented Approach to 3D Graphics" and "The VTK User's Guide." Moving forward, Kitware plans to write new versions of the books and to transfer the books to open repositories. To download the books, please visit http://www.vtk.org/vtk-textbook and http://www.vtk.org/vtk-users-guide.

KITWARE PREPARES SC16 PRESENTATION ON RECORD-BREAKING IN SITU RUNKitware has scheduled two times, during which it will deliver a presentation that provides exclusive insight on the largest-known in situ simulation run at its booth (3437) at The International Conference for High Performance Computing, Networking, Storage and Analysis (SC16). The presentation times will begin on Monday, November 14, 2016, at 7:30 p.m.

15

MDT and on Tuesday, November 15, 2016, at 11:00 a.m. MDT, respectively.

Kitware participated on a team that worked with collabora-tors to complete the run for a project earlier this year. As part of the project, the team aims to create an infrastructure that can execute algorithms that users write across in situ software implementations. The particular implementation that the team used for the largest-known in situ simulation run combined ParaView Catalyst and SENSEI.

“ParaView Catalyst provides a lightweight ParaView server library, and SENSEI offers an interface that transfers analysis code among in situ infrastructures,” said Andrew Bauer, Ph.D., the lead developer of ParaView Catalyst at Kitware. “ParaView Catalyst and SENSEI streamline the simulation pipeline. Together, they enabled us to complete a larger run than ever before.”

For the run, ParaView Catalyst and SENSEI computed the Parallel Hierarchic Adaptive Stabilized Transient Analysis (PHASTA) simulation code. The run employed a 6.3 billion-cell unstructured grid and used 32,768 out of 49,152 nodes on Mira, an IBM Blue Gene/Q supercomputer from Argonne Leadership Computing Facility at Argonne National Laboratory. With 1,048,576 Message Passing Interface (MPI) processes on over 500,000 cores, the run quadrupled the size of the previous largest-known in situ simulation run. While the previous run also computed PHASTA with ParaView Catalyst, it did not utilize SENSEI.

“With ParaView Catalyst, users can specify which visual-ization and analysis capabilities of ParaView they seek to implement,” Bauer said. “Now, with SENSEI, users can better leverage in situ infrastructures to reduce runtime.”

ParaView Catalyst visualizes flow around a jet for the largest-known in situ simulation run. Kitware will feature

this image at its SC16 booth (3437).

The total runtime for the simulation clocked in at 653 seconds. Of this total, the time for in situ computation com-prised 13 percent. During SC16, Kitware will address how information gleaned from the simulation run guided the development community to update ParaView. With these updates, the team projects that the total runtime for the same simulation would now come to 601 seconds, and the

time for in situ computation would reduce to 5.6 percent of the total.

The SC16 presentation will complement a paper that team members wrote with collaborators for the conference. The paper, “Performance Analysis, Design Considerations, and Applications of Extreme-scale In Situ Infrastructures,” reviews in situ computation and shares additional results of the largest-known in situ simulation run. As well as Bauer, authors on the paper include Utkarsh Ayachit, Earl P. N. Duque, Greg Eisenhauer, Nicola Ferrier, Junmin Gu, Kenneth E. Jansen, Burlen Loring, Zarija Lukic, Suresh Menon, Dmitriy Morozov, Patrick O’Leary, Reetesh Ranjan, Michel Rasquin, Christopher P. Stone, Venkat Vishwanath, Gunther H. Weber, Brad Whitlock, Matthew Wolf, K. John Wu, and E. Wes Bethel. Bethel will discuss the paper at the State-of-the-Practice: System Characterization and Design session at the confer-ence. The session will take place on Thursday, November 17, 2016, from 4:00 p.m. to 4:30 p.m. MDT in room 355-D of the Salt Palace Convention Center.

To learn more about the largest-known in situ simulation run, SC16 attendees can visit the Kitware booth during the conference exhibition from November 14 to November 17, 2016. Along with the exhibition, Kitware will participate in a number of conference activities that highlight its tech-nology and expertise in high-performance computing and visualization. For details on scheduled activities, please refer to the event listing on the Kitware blog. To set up a time to meet with Kitware team members at SC16, please email kitware(at)kitware.com.

This material is based upon work supported by the U.S. Department of Energy, Office of Science, under Award Number DE-SC0012387.

This report was prepared as an account of work sponsored by an agency of the United States Government. Neither the United States Government nor any agency thereof, nor any of their employees, makes any warranty, express or implied, or assumes any legal liability or responsibility for the accuracy, completeness, or usefulness of any information, apparatus, product, or process disclosed, or represents that its use would not infringe privately owned rights. Reference herein to any specific commercial product, process, or service by trade name, trademark, manufacturer, or otherwise does not necessarily constitute or imply its endorsement, recom-mendation, or favoring by the United States Government or any agency thereof. The views and opinions of authors expressed herein do not necessarily state or reflect those of the United States Government or any agency thereof.

KITWARE WELCOMES AND CONGRATULATES TEAM MEMBERSJared VicoryVicory started a new position as a research and develop-ment engineer on the medical computing team. He came to Kitware in May 2016 as an intern.

16

Contributors: Lisa Avila, Andrew Bauer, Alex Bigelow, Roni Choudhury, Guido Gerig, Buvana Jayaraman, Matthew McCormick, Mark Potsdam, Libby Rose, Jared Vicory, Andrew Wissink, Paul Yushkevich, and Dženan Zukic

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.

Alexis GiraultGirault returned to Kitware full time. He previously worked as an intern in Carrboro, North Carolina.

Pierre GuilbertGuilbert began his role as an engineer in Lyon, France. His knowledge includes C++, Python, OpenCV, Open GL, OpenMP, Qt, and Visual Studio.

Jérôme CosteCoste joined Kitware as an intern in Lyon, France. He cur-rently attends Université de Technologie de Compiègne.

Hina ShahShah joined the medical computing team in Carrboro, North Carolina. In previous positions, Shah developed algorithms, tools, and applications for medical imaging.

Mohit TyagiTyagi came to the Carrboro office as a long-term intern. He received a doctorate in mechanical engineering from Rensselaer Polytechnic Institute in May 2016.

Lucie Macron Macron transitioned to a full-time team member. As a student at École Supérieure de Chimie Physique Électronique de Lyon, she completed an internship at Kitware SAS earlier this year.

Ashleigh SmithSmith filled the role of controller on the finance team. For prior efforts, she completed audits as well as internal control

risk assessments. She also led training sessions on technical accounting.

Beatriz “Bea” PaniaguaPaniagua made the move to Kitware as part of the Carrboro office. Prior to joining Kitware, Bea was an assistant profes-sor at the Neuro Imaging Research and Analysis Laboratories at the University of North Carolina at Chapel Hill, where she focused on computer-aided diagnosis of craniofacial dismor-phology and craniofacial surgery planning.

Louis AmoreAmore became a full-time team member in Lyon, France. In March 2016, he commenced an internship at Kitware, while he pursued a graduate degree from Université Claude Bernard Lyon 1.

Kitware continues to seek talented, motivated, and creative individuals to develop and deliver cutting-edge software products and services. Kitware employees enjoy an award-winning work environment that empowers them to pursue their passions. In addition to an excellent work environment, Kitware offers comprehensive benefits including flexible hours; a computer hardware budget; health, vision, dental, and life insurance; short- and long-term disability insur-ance; immigration- and visa-processing services; a relocation bonus; tuition reimbursement; and a generous compensa-tion plan.

For descriptions of available positions, please see http://jobs.kitware.com/opportunities.html.