The simulation of physical phenomena involving the dynamic behavior of fluids and gases has numerous applications in various fields of science and engineering. Of particular interest is the material transport behavior, the tendency of a flow field to displace parts of the medium. Therefore, many visualization techniques rely on particle trajectories. Lagrangian Flow Field Representation. In typical Eulerian settings, trajectories are computed from the simulation output using numerical integration schemes. Accuracy concerns arise because, due to limitations of storage space and bandwidth, often only a fraction of the computed simulation time steps are available. Prior work has shown empirically that a Lagrangian, trajectory-based representation can improve accuracy [Agr+14]. Determining the parameters of such a representation in advance is difficult; a relationship between the temporal and spatial resolution and the accuracy of resulting trajectories needs to be established. We provide an error measure for upper bounds of the error of individual trajectories. We show how areas at risk for high errors can be identified, thereby making it possible to prioritize areas in time and space to allocate scarce storage resources. Comparative Visual Analysis of Flow Field Ensembles. Independent of the representation, errors of the simulation itself are often caused by inaccurate initial conditions, limitations of the chosen simulation model, and numerical errors. To gain a better understanding of the possible outcomes, multiple simulation runs can be calculated, resulting in sets of simulation output referred to as ensembles. Of particular interest when studying the material transport behavior of ensembles is the identification of areas where the simulation runs agree or disagree. We introduce and evaluate an interactive method that enables application scientists to reliably identify and examine regions of agreement and disagreement, while taking into account the local transport behavior within individual simulation runs. Particle-Based Representation and Visualization of Uncertain Flow Data Sets. Unlike simulation ensembles, where uncertainty of the solution appears in the form of different simulation runs, moment-based Eulerian multi-phase fluid simulations are probabilistic in nature. These simulations, used in process engineering to simulate the behavior of bubbles in liquid media, are aimed toward reducing the need for real-world experiments. The locations of individual bubbles are not modeled explicitly, but stochastically through the properties of locally defined bubble populations. Comparisons between simulation results and physical experiments are difficult. We describe and analyze an approach that generates representative sets of bubbles for moment-based simulation data. Using our approach, application scientists can directly, visually compare simulation results and physical experiments.

We present a study comparing the effect of real-time wearable feedback with traditional training methods for cardiopulmonary resuscitation (CPR). The aim is to ensure that the students can deliver CPR with the right compression speed and depth. On the wearable side, we test two systems: one based on a combination of visual feedback and tactile information on a smart-watch and one based on visual feedback and audio information on a Google Glass. In a trial with 50 subjects (23 trainee nurses and 27 novices,) we compare those modalities to standard human teaching that is used in nurse training. While a single traditional teaching session tends to improve only the percentage of correct depth, it has less effect on the percentage of effective CPR (depth and speed correct at the same time). By contrast, in a training session with the wearable feedback device, the average percentage of time when CPR is effective improves by up to almost 25%.

Novel image processing techniques have been in development for decades, but most of these techniques are barely used in real world applications. This results in a gap between image processing research and real-world applications; this thesis aims to close this gap. In an initial study, the quantification, propagation, and communication of uncertainty were determined to be key features in gaining acceptance for new image processing techniques in applications. This thesis presents a holistic approach based on a novel image processing pipeline, capable of quantifying, propagating, and communicating image uncertainty. This work provides an improved image data transformation paradigm, extending image data using a flexible, high-dimensional uncertainty model. Based on this, a completely redesigned image processing pipeline is presented. In this pipeline, each step respects and preserves the underlying image uncertainty, allowing image uncertainty quantification, image pre-processing, image segmentation, and geometry extraction. This is communicated by utilizing meaningful visualization methodologies throughout each computational step. The presented methods are examined qualitatively by comparing to the Stateof- the-Art, in addition to user evaluation in different domains. To show the applicability of the presented approach to real world scenarios, this thesis demonstrates domain-specific problems and the successful implementation of the presented techniques in these domains.

In recent years, enormous progress has been made in the field of Artificial Intelligence (AI). Especially the introduction of Deep Learning and end-to-end learning, the availability of large datasets and the necessary computational power in form of specialised hardware allowed researchers to build systems with previously unseen performance in areas such as computer vision, machine translation and machine gaming. In parallel, the Semantic Web and its Linked Data movement have published many interlinked RDF datasets, forming the world’s largest, decentralised and publicly available knowledge base. Despite these scientific successes, all current systems are still narrow AI systems. Each of them is specialised to a specific task and cannot easily be adapted to all other human intelligence tasks, as would be necessary for Artificial General Intelligence (AGI). Furthermore, most of the currently developed systems are not able to learn by making use of freely available knowledge such as provided by the Semantic Web. Autonomous incorporation of new knowledge is however one of the pre-conditions for human-like problem solving. This work provides a small step towards teaching machines such human-like reasoning on freely available knowledge from the Semantic Web. We investigate how human associations, one of the building blocks of our thinking, can be simulated with Linked Data. The two main results of these investigations are a ground truth dataset of semantic associations and a machine learning algorithm that is able to identify patterns for them in huge knowledge bases. The ground truth dataset of semantic associations consists of DBpedia entities that are known to be strongly associated by humans. The dataset is published as RDF and can be used for future research. The developed machine learning algorithm is an evolutionary algorithm that can learn SPARQL queries from a given SPARQL endpoint based on a given list of exemplary source-target entity pairs. The algorithm operates in an end-to-end learning fashion, extracting features in form of graph patterns without the need for human intervention. The learned patterns form a feature space adapted to the given list of examples and can be used to predict target candidates from the SPARQL endpoint for new source nodes. On our semantic association ground truth dataset, our evolutionary graph pattern learner reaches a Recall@10 of > 63 % and an MRR (& MAP) > 43 %, outperforming all baselines. With an achieved Recall@1 of > 34% it even reaches average human top response prediction performance. We also demonstrate how the graph pattern learner can be applied to other interesting areas without modification.

Computational problems that involve dynamic data, such as physics simulations and program development environments, have been an important subject of study in programming languages. Recent advances in self-adjusting computation made progress towards achieving efficient incremental computation by providing algorithmic language abstractions to express computations that respond automatically to dynamic changes in their inputs. Selfadjusting programs have been shown to be efficient for a broad range of problems via an explicit programming style, where the programmer uses specific primitives to identify, create and operate on data that can change over time. This dissertation presents implicit self-adjusting computation, a type directed technique for translating purely functional programs into self-adjusting programs. In this implicit approach, the programmer annotates the (toplevel) input types of the programs to be translated. Type inference finds all other types, and a type-directed translation rewrites the source program into an explicitly self-adjusting target program. The type system is related to information-flow type systems and enjoys decidable type inference via constraint solving. We prove that the translation outputs well-typed self-adjusting programs and preserves the source program’s input-output behavior, guaranteeing that translated programs respond correctly to all changes to their data. Using a cost semantics, we also prove that the translation preserves the asymptotic complexity of the source program. As a second contribution, we present two techniques to facilitate the processing of large and dynamic data in self-adjusting computation. First, we present a type system for precise dependency tracking that minimizes the time and space for storing dependency metadata. The type system improves the scalability of self-adjusting computation by eliminating an important assumption of prior work that can lead to recording spurious dependencies. We present a type-directed translation algorithm that generates correct selfadjusting programs without relying on this assumption. Second, we show a probabilistic-chunking technique to further decrease space usage by controlling the fundamental space-time tradeoff in self-adjusting computation. We implement implicit self-adjusting computation as an extension to Standard ML with compiler and runtime support. Using the compiler, we are able to incrementalize an interesting set of applications, including standard list and matrix benchmarks, ray tracer, PageRank, sparse graph connectivity, and social circle counts. Our experiments show that our compiler incrementalizes existing code with only trivial amounts of annotation, and the resulting programs bring asymptotic improvements to large datasets from real-world applications, leading to orders of magnitude speedups in practice.