Dissertations / Theses on the topic 'Computer animation – Data processing'

Large-scale medical imaging studies to date have predominantly leveraged in-house, laboratory-based or traditional grid computing resources for their computing needs, where the applications often use hierarchical data structures (e.g., Network file system file stores) or databases (e.g., COINS, XNAT) for storage and retrieval. The resulting performance for laboratory-based approaches reveal that performance is impeded by standard network switches since typical processing can saturate network bandwidth during transfer from storage to processing nodes for even moderate-sized studies. On the other hand, the grid may be costly to use due to the dedicated resources used to execute the tasks and lack of elasticity. With increasing availability of cloud-based big data frameworks, such as Apache Hadoop, cloud-based services for executing medical imaging studies have shown promise.

Despite this promise, our studies have revealed that existing big data frameworks illustrate different performance limitations for medical imaging applications, which calls for new algorithms that optimize their performance and suitability for medical imaging. For instance, Apache HBases data distribution strategy of region split and merge is detrimental to the hierarchical organization of imaging data (e.g., project, subject, session, scan, slice). Big data medical image processing applications involving multi-stage analysis often exhibit significant variability in processing times ranging from a few seconds to several days. Due to the sequential nature of executing the analysis stages by traditional software technologies and platforms, any errors in the pipeline are only detected at the later stages despite the sources of errors predominantly being the highly compute-intensive first stage. This wastes precious computing resources and incurs prohibitively higher costs for re-executing the application. To address these challenges, this research propose a framework - Hadoop & HBase for Medical Image Processing (HadoopBase-MIP) - which develops a range of performance optimization algorithms and employs a number of system behaviors modeling for data storage, data access and data processing. We also introduce how to build up prototypes to help empirical system behaviors verification. Furthermore, we introduce a discovery with the development of HadoopBase-MIP about a new type of contrast for medical imaging deep brain structure enhancement. And finally we show how to move forward the Hadoop based framework design into a commercialized big data / High performance computing cluster with cheap, scalable and geographically distributed file system.

Today, a large amount of spatial data is generated from a variety of sources, such as mobile devices, sensors, and satellites. Traditional spatial data processing techniques no longer satisfy the efficiency and scalability requirements for large-scale spatial data processing. Existing Big Data processing frameworks such as Hadoop and Spark have been extended to support effective large-scale spatial data processing. In addition to processing data in distributed schemes utilizing computer clusters for efficiency and scalability, single node performance can also be improved by making use of multi-core processors. In this thesis, we investigate approaches to parallelize line segment intersection algorithms for spatial computations on multi-core processors, which can be used as node-level algorithms for distributed spatial data processing. We first provide our design of line segment intersection algorithms and introduce parallelization techniques. Then, we describe experimental results using multiple data sets and speed ups are examined with varying numbers of processing cores. Equipped with the efficient underlying algorithm for spatial computation, we investigate how to build a native big spatial data system from the ground up. We provide a system design for distributed large-scale spatial data management and processing using a two-level hash based Quadtree index as well as algorithms for spatial operations.

In the era of big data, many cluster platforms and resource management schemes are created to satisfy the increasing demands on processing a large volume of data. A general setting of big data processing jobs consists of multiple stages, and each stage represents generally defined data operation such as ltering and sorting. To parallelize the job execution in a cluster, each stage includes a number of identical tasks that can be concurrently launched at multiple servers. Practical clusters often involve hundreds or thousands of servers processing a large batch of jobs. Resource management, that manages cluster resource allocation and job execution, is extremely critical for the system performance.

Generally speaking, there are three main challenges in resource management of the new big data processing systems. First, while there are various pending tasks from dierent jobs and stages, it is difficult to determine which ones deserve the priority to obtain the resources for execution, considering the tasks' different characteristics such as resource demand and execution time. Second, there exists dependency among the tasks that can be concurrently running. For any two consecutive stages of a job, the output data of the former stage is the input data of the later one. The resource management has to comply with such dependency. The third challenge is the inconsistent performance of the cluster nodes. In practice, run-time performance of every server is varying. The resource management needs to dynamically adjust the resource allocation according to the performance change of each server.

The resource management in the existing platforms and prior work often rely on fixed user-specic congurations, and assumes consistent performance in each node. The performance, however, is not satisfactory under various workloads. This dissertation aims to explore new approaches to improving the eciency of large-scale big data processing platforms. In particular, the run-time dynamic factors are carefully considered when the system allocates the resources. New algorithms are developed to collect run-time data and predict the characteristics of jobs and the cluster. We further develop resource management schemes that dynamically tune the resource allocation for each stage of every running job in the cluster. New findings and techniques in this dissertation will certainly provide valuable and inspiring insights to other similar problems in the research community.

Under sommaren 2006 öppnar Mälsåker Slott för allmänheten och ett av de planerade projekten är en multimedial utställning om norrmän som tränades där i hemlighet under andra världskriget.

Författarna till denna rapport är alla studenter av informationsdesign, med inriktning mot illustration på Mälardalens Högskola. Då vi har ett stort intresse av animation föreföll detta projekt mycket intressant.

Vi ingick i en projektgrupp som innefattade dataloger, textdesigners samt illustratörer. Illustratörernas del av projektet var att skapa det visuella materialet på ett intresseväckande sätt. I rapporten undersöks möjliga lösningar för animation, manér, bilddramaturgi samt de tekniska förutsättningar som krävs för att skapa ett lyckat slutresultat. Rapporten beskriver tillvägagångssättet för att uppnå dessa mål vilket inkluderar metoder som litteraturstudier, diskussioner samt utprovningar. Utställningsformen är experimentell och arbetet har därför givit ett slutresultat som kan ses som en

fallstudie i sig.

Utprovningar av det färdiga materialet visar att vi efter förutsättningarna lyckats uppnå ett gott resultat. Animerat bildspel fungerar i sammanhanget bra som informativt utställningsmaterial.

Developers using the SQL language lack relational SQL debugging tools. SQL also suffers from a lack of sufficient automated frameworks for unit testing and regression testing of queries. This thesis begins with an SQL bug taxonomy. The focus is on Core SQL as defined in the SQL:1999 standard. Features in Core SQL remain virtually unchanged through the latest standard, SQL:2011. Our bug taxonomy illustrates common coding defects related to NULL, LEFT JOIN, selectivity assumptions, and ordering assumptions. We highlight ways that silent failures can impact a databasedependent application. Our proposal for addressing SQL development errors is a verification tool (named POQ) that leverages annotated postconditions attached to each query statement. The formalism of domain relational calculus is the basis for axiomatizing queries. Subsequently, a theorem prover searches for counterexamples that demonstrate when the postcondition fails. Alternative projects using SMT solvers and static analysis methods are also discussed.

Edge-labeled graphs have proliferated rapidly over the last decade due to the increased popularity of social networks and the Semantic Web. In social networks, relationships between people are represented by edges and each edge is labeled with a semantic annotation. Hence, a huge single graph can express many different relationships between entities. The Semantic Web represents each single fragment of knowledge as a triple (subject, predicate, object), which is conceptually identical to an edge from subject to object labeled with predicates. A set of triples constitutes an edge-labeled graph on which knowledge inference is performed.

Subgraph matching has been extensively used as a query language for patterns in the context of edge-labeled graphs. For example, in social networks, users can specify a subgraph matching query to find all people that have certain neighborhood relationships. Heavily used fragments of the SPARQL query language for the Semantic Web and graph queries of other graph DBMS can also be viewed as subgraph matching over large graphs.

Though subgraph matching has been extensively studied as a query paradigm in the Semantic Web and in social networks, a user can get a large number of answers in response to a query. These answers can be shown to the user in accordance with an importance ranking. In this thesis proposal, we present four different scoring models along with scalable algorithms to find the top-k answers via a suite of intelligent pruning techniques. The suggested models consist of a practically important subset of the SPARQL query language augmented with some additional useful features.

The first model called Substitution Importance Query (SIQ) identifies the top-k answers whose scores are calculated from matched vertices' properties in each answer in accordance with a user-specified notion of importance. The second model called Vertex Importance Query (VIQ) identifies important vertices in accordance with a user-defined scoring method that builds on top of various subgraphs articulated by the user. Approximate Importance Query (AIQ), our third model, allows partial and inexact matchings and returns top-k of them with a user-specified approximation terms and scoring functions. In the fourth model called Probabilistic Importance Query (PIQ), a query consists of several sub-blocks: one mandatory block that must be mapped and other blocks that can be opportunistically mapped. The probability is calculated from various aspects of answers such as the number of mapped blocks, vertices' properties in each block and so on and the most top-k probable answers are returned.

An important distinguishing feature of our work is that we allow the user a huge amount of freedom in specifying: (i) what pattern and approximation he considers important, (ii) how to score answers - irrespective of whether they are vertices or substitution, and (iii) how to combine and aggregate scores generated by multiple patterns and/or multiple substitutions. Because so much power is given to the user, indexing is more challenging than in situations where additional restrictions are imposed on the queries the user can ask.

The proposed algorithms for the first model can also be used for answering SPARQL queries with ORDER BY and LIMIT, and the method for the second model also works for SPARQL queries with GROUP BY, ORDER BY and LIMIT. We test our algorithms on multiple real-world graph databases, showing that our algorithms are far more efficient than popular triple stores.