With the fast growing volume of 3D point-cloud data, innovative point-cloud visualization techniques are in need for efficient and accurate information presentation and navigation. In this paper, we propose a hierarchical RBF based approach to interactively visualize 3D point-cloud. With this approach users are able to achieve better resolution in a Region of Interest(ROI) without having to transmit and render the entire object in high detail.

This paper shows that it is possible to build a maximal and sound causal model for concurrent computations from a given execution trace. It is sound, in the sense that any program which can generate a trace can also generate all traces in its causal model. It is maximal (among sound models), in the sense that by extending the causal model of an observed trace with a new trace, the model becomes unsound: there exists a program generating the original trace which cannot generate the newly introduced trace. Thus, the maximal sound model has the property that it comprises all traces which all programs that can generate the original trace can also generate. The existence of such a model is of great theoretical value as it can be used to prove the soundness of non-maximal, and thus smaller, causal models.

Bridging rules take the antecedent and action from different conceptual clusters. They are distinguished from association rules (frequent itemsets) because (1) they can be generated by the infrequent itemsets that are pruned in association rule mining, and (2) they are measured by their importance including the distance between two conceptual clusters, whereas frequent itemsets are measured only by their support. In this paper, we first design two algorithms for mining bridging rules between clusters, and then propose two non-linear metrics to measure their interestingness. We evaluate these algorithms experimentally and demonstrate that our approach is promising.

This article gives an overview of the, monitoring oriented programming framework (MOP). In MOP, runtime monitoring is supported and encouraged as a fundamental principle for building reliable systems. Monitors are automatically synthesized from specified properties and are used in conjunction with the original system to check its dynamic behaviors. When a specification is violated or validated at runtime, user-defined actions will be triggered, which can be any code, such as information logging or runtime recovery. Two instances of MOP are presented: JavaMOP (for Java programs) and BusMOP (for monitoring PCI bus traffic). The architecture of MOP is discussed, and an explanation of parametric trace monitoring and its implementation is given. A comprehensive evaluation of JavaMOP attests to its efficiency, especially in comparison with similar systems. The implementation of BusMOP is discussed in detail. In general, BusMOP imposes no runtime overhead on the system it is monitoring.

Genomics represents a research of the whole genome, which includes the investigation of DNA, RNA, protein, relationships between them and so on. Pattern recognition (PR) focuses on classifying or clustering data according to either prior knowledge or statistical information in the multi-dimensional data space. When the traditional laboratory techniques can not extract useful information from the increasing biological databases, introducing PR, as well as data mining and machine learning, is a good way to analyze genomics data. This chapter reviews important pattern recognition techniques and their applications in genomics.

Computer games have become one of the preferred choices for entertainment in our society primarily because they are interactive, have appealing multimedia content, and provide an immersive and rewarding environment for players. These qualities constitute an essential psychophysical factor that inspires learning abilities and new knowledge. Despite all these promising elements, studies have shown that current educational games are not as effective as they could be. A lack of adaptive tutoring and feedback tools, lack of proper knowledge assessment, and weakly designed gameplay are the major factors for their inefficiency. We address these problems by proposing an Intelligent Tutoring System (ITS) for computer games. An important contribution of this ITS is its capability to track player intentions and award partial marks, which provides more accurate assessment than simply giving full mark to the correct result and none to an incorrect answer. Two strategies adopted in this system are Bayesian Networks based student modeling and individualized tutoring. The system can incorporate one or more games and can address one or more educational topic. The information collected from student interaction with computer games is used to update a student module that reports a student’s current level of knowledge, making adaptive tutoring and assessment with computer games more effective. In order to provide an engaging and interactive environment, each game in the system has a local student module constructed based on a Dynamic Bayesian Network. We describe the design and evaluation of our ITS using a prototype implementation with several game examples. Positive evaluation results support the feasibility of the proposed system.

This paper shows that it is possible to build a theoretically maximal and sound causal model for concurrent computations from a given execution trace. For an observed execution, the proposed model comprises all consistent executions which can be derived from it using only knowledge about the execution machine. The existence of such a model is of great theoretical value. First, by comprising all feasible executions, it can be used to prove soundness of other causal models: indeed, several models underlying existing techniques are shown to be embedded into the maximal model, so all these models are sound. Second, since it is maximal, the proposed model allows for natural and causal-model-independent definitions of trace-based properties; this paper proposes maximal definitions for causal dataraces and causal atomicity. Finally, although defined axiomatically, the set of traces comprised by the proposed model are shown to be effectively constructed from an initial observed trace. Thus, maximal causal models are not only theoretically relevant, but they are also amenable for developing practical analysis tools.

This paper discusses using a forward error correction (FEC) algorithm to protect the transmission of progressively compressed 3D point clouds against packets loss. We design a metric to evaluate each layer's quality contribution to the decoding result of the progressively compressed model. With this metric, we minimize the expected distortion when applying an Unequal Error Protection (UEP) strategy to allocate channel bits to different layers of the model. The performance of employing UEP and Equal Error Protection (EEP) are compared with respect to the expected distortion. Experimental results show that by incorporating our distortion estimation metric with UEP, the rendering quality of a reconstructed 3D model degrades more gracefully as the packet-loss rate increases.

Multi-viewpoint video has recently gained significant attention in academic and commercial fields. In this work, we propose a new method for incorporating 3D point cloud models into multi-viewpoint video. First, we synthesize virtual multi-viewpoint video utilizing depth and texture maps of the input video. Then, we integrate 3D point cloud models with the resulting multi-viewpoint video generated in the first step by analyzing the depth information. As shown in our experiments, 3D point clouds can be seamlessly inserted into a multi-viewpoint video and realistic effect can be obtained. In addition, we compare the virtual viewpoint image generated by interpolating the two nearest neighbor cameras and by re-projecting the nearest camera.

We present an extension of past time LTL with call/return atoms, called ptCaRet, together with a monitor synthesis algorithm for it. ptCaRet includes abstract variants of past temporal operators, which can express properties over traces in which terminated function or procedure executions are abstracted away into a call and a corresponding return. This way, ptCaRet can express safety properties about procedural programs which cannot be expressed using conventional linear temporal logics. The generated monitors contain both a local state and a stack. The local state is encoded on as many bits as concrete temporal operators the original formula has. The stack pushes/pops bit vectors of size the number of abstract temporal operators the original formula has: push on begins, pop on ends of procedure executions. An optimized implementation is also discussed and is available to download.

Events represent atomic steps observed in the execution of a program. In this paper, we focus on multi-threaded programs and consider the following types of events (other types can be easily added): write/read of variables, and acquiring/releasing of locks. A statement in the program may produce multiple events. Events need to store enough information about the program state to allow the observer to analyze the trace. To allow for a general treatment of events, we here consider events to be abstract entities from an infinite “collection” Events. Events can be “observed” through (partial) attribute mappings from Events to a concrete domain. We will describe events by a tuple of pairs attribute:value listing the value of each defined attribute mapping for the particular event. The only attribute mappings considered in this paper will be: thread – the thread generating the event, type – the type of the event, target – the memory location accessed by the event, and state – the value read/written by the current event. For example, the description of an event could be e1 : (thread = t1, type = write, target = x, state = 1), which says that event e1 is a write on location x with value 1, produced by thread t1. Note that the identity of an event is not reduced to the identity of the attributes defined for that event, so we could have two events with identical attributes, yet distinct.

jPredictor is a tool for detecting concurrency errors in Java programs. The Java program is instrumented to emit property-relevant events at runtime and then executed. The resulting execution trace is collected and analyzed by Predictor, which extracts a causality relation sliced using static analysis and refined with lock-atomicity information. The resulting abstract model, a hybrid of a partial order and atomic blocks, is then exhaustively analyzed against the property and errors with counter-examples are reported to the user. Thus, jPredictor can "predict" errors that did not happen in the observed execution, but which could have happened under a different thread scheduling. The analysis technique employed in jPredictor is fully automatic, generic (works for any trace property), sound (produces no false alarms) but it is incomplete may miss errors). Two common types of errors are investigated in this paper: dataraces and atomicity violations. Experiments show that jPredictor is precise (in its predictions), effective and efficient. After the code producing them was executed only once, jPredictor found all the errors reported by other tools. It also found errors missed by other tools, including static race detectors, as well as unknown errors in popular systems like Tomcat and the Apache FTP server.

Dimensional safety policy checking is an old topic in software analysis concerned with ensuring that programs do not violate basic principles of units of measurement. Scientific and/or navigation software is routinely dimensional and violations of measurement unit safety policies can hide significant domain-specific errors which are hard or impossible to find otherwise. Dimensional analysis of programs written in conventional programming languages is addressed in this paper, as part of our general efforts in domain-specific software certification. We draw general design principles for dimensional analysis tools and then discuss our prototypes which include both dynamic and static checkers. Our approach is based on assume/assert annotations (comments) of code which are properly interpreted by our tools and ignored by standard programming language compilers or interpreters, so we do not modify the underlying programming language at all. The output of our prototypes consists of warnings that list those expressions violating the unit safety policy.

Monitoring-oriented programming (MOP) is a software development and analysis technique in which monitoring plays a fundamental role. MOP users can add their favorite or domain-specific requirements specification formalisms into the framework by means of logic plug-ins, which essentially comprise monitor synthesis algorithms for properties expressed as formulae. The properties are specified together with declarations stating where and how to automatically integrate the corresponding monitor into the system, as well as what to do if the property is violated or validated. In this paper we present Java-MOP, an MOP environment for developing robust Java applications. Based upon a carefully designed specification schema and upon several logic plug-ins, Java-MOP allows users to specify and monitor properties which can refer not only to the current program state, but also to the entire execution trace of a program, including past and future behaviors.

A parametric approach to control dependence is presented, where the parameter is any prefix-invariant property on paths in the control-flow graph (CFG). Existing control dependencies, both direct and indirect, can be obtained as instances of the parametric framework for particular properties on paths. A novel control dependence relation, called termination-sensitive control dependence, is obtained also as an instance of the parametric framework. This control dependence is sensitive to the termination information of loops, which can be given via annotations. If all loops are annotated as terminating then it becomes the classic control dependence, while if all loops are annotated as non-terminating then it becomes the weak control dependence; since in practice some loops are terminating and others are not, termination-sensitive control dependence is expected to improve the precision of analysis tools using it. The unifying formal framework for direct and indirect control dependence suggests also, in a natural way, a unifying terminology for the various notions of control dependence, which is also proposed in this paper. Finally, a worst-case O(n2) algorithm to compute the indirect termination-sensitive control dependence for languages that allow only “structured” jumps (i.e., ones that do not jump into the middle of a different block), such as Java and C#, is given, avoiding the O(n3) complexity of the trivial algorithm calculating the transitive closure of the direct dependence.