There are several methods to visualize time series data such as line graphs, stacked graphs, and heatmaps. Line graphs have an advantage that it is easy to read the values of the data and the increase or decrease in the values from the slopes of lines. However, line graphs lack visibility when the numbers of lines increase. By contrast, heatmaps do not lessen visibility by the increase of the data but require more visualizing space. Also, it is more difficult to read values from heatmaps than from line graphs. This paper proposes a method that combines heatmaps and line graphs to make it easier to recognize the features and the exact values of the data. The time series data are clustered by their similarity and each cluster will be drawn as a band shape rectangle. By clicking on the rectangle, the data belonging to the cluster will be drawn as a line graph next to the heatmap area. The number of drawn clusters can be changed by a slider. An experiment was conducted to compare the data readability of the proposed method with that of line graphs and that of heatmaps. The results show that the method provides users a higher readability of exact values than the line graphs and the heatmaps.

Constraint programming is a powerful tool for modeling and solving various problems. Especially, soft constraints are useful since they enable the treatment of over-and under-constrained real-world problems by relaxing conflicting constraints and introducing default constraints. Constraint hierarchies provide a soft constraint framework that introduces hierarchical preferences called strengths. In a constraint hierarchy, constraints are associated with strengths such as required, strong, medium, and weak, and a solution is obtained to maximally satisfy stronger constraints in the sense of a given solution criterion. In this paper, we propose three methods based on binary search for solving constraint hierarchies over finite domains by using a criterion called unsatisfied-count-better. Our methods solve constraint hierarchies by encoding them into ordinary constraint satisfaction problems and repeatedly solving the encoded problems with an external solver. We also present the implementations of our methods and the results of the experiment that we conducted to evaluate them.

To exhaustively understand the impact of rule amendments and unforeseen cases on existing norms, it requires connecting their rule-based and case-based representations. However, those connections have not been explored in depth, especially for norms that are represented as soft constraints. This paper aims to explore the connection between constraint hierarchies and case models as representative formalisms of rule-based and case-based representations of soft-constraint norms respectively. To explore the connection, we express norm scopes and preferences in both formalisms as diagrams. Based on tightening and arranging diagrams, we found the translation of constraint hierarchies with one constraint per level into case models. This provides new insights into understanding prototypical cases made by rule-based soft-constraint norms.

Increasingly more people are using tablets for various tasks such as browsing websites, reading and writing email messages, making notes, and even creating business documents, for which they often need to enter text. When people enter text with tablets, they usually use software keyboards on the touch screens of the tablets. Unlike hardware keyboards that normally allow users to put their fingertips on keys, software keyboards require users to keep their fingertips in the air except when they actually perform input by tapping the screens, which may cause fatigue to the users. In this paper, we propose a Japanese software keyboard for tablets that reduces user fatigue. Our software keyboard allows its user to put his/her fingertips on the touch screen by distinguishing the user's intended tapping from his/her touching the screen without intending to input. We evaluated the keyboard by conducting a user study that compared it with a software keyboard based on normal tapping. The results of the user study show that our software keyboard caused less fatigue to the users in several regions of their bodies than the normal keyboard, although it resulted in a longer average time length and a worse average error rate of the users' text entry.

Newspapers and other media often describe particular topics over some periods by giving a series of texts that introduces new information and corrects previous information. By analyzing such texts, we can understand how a topic changed over time and how the media treated it. However, analyzing such texts manually is time-consuming. To solve this problem, we propose a method for visualizing texts that describe a topic changing over time. For this purpose, we first generate an event information graph from such texts by using an existing method. Then we transform it into two different graphs. The first graph shows changes in the topic that we obtain by separating the initial graph and comparing the resulting time-dependent graphs. The second graph depicts a summary of the topic that we obtain by extracting high-frequency words from the initial graph. The results of our experiment show that our method can visualize changes and important information described in the texts.

Block-based visual programming (BVP) is becoming popular as a basis of programming education. It allows beginners to visually construct programs without suffering from syntax errors. However, a typical user interface for BVP is inefficient partly because the users need to perform many drag-and-drop operations to put blocks on a program, and also partly because they need to find necessary blocks from many choices. To improve the efficiency of constructing programs in a BVP system, we propose a user interface that introduces three new features: (1) the semiautomatic addition of blocks; (2) the use of a pie menu to change categories of blocks; (3) the focus+context visualization of blocks in a category. We implemented a prototype BVP system with the new user interface.

The paper tackles the problems of the “giant hairballs”, the dense and tangled structures often resulting from visualization of large social graphs. Proposed is a high-dimensional rotation technique called AGI3D, combined with an ability to filter elements based on social centrality values. AGI3D is targeted for a high-dimensional embedding of a social graph and its projection onto 3D space. It allows the user to rotate the social graph layout in the high-dimensional space by mouse dragging of a vertex. Its high-dimensional rotation effects give the user an illusion that he/she is destructively reshaping the social graph layout but in reality, it assists the user to find a preferred positioning and direction in the high-dimensional space to look at the internal structure of the social graph layout, keeping it unmodified. A prototype implementation of the proposal called Social Viewpoint Finder is tested with about 70 social graphs and this paper reports four of the analysis results.

In formula-based fault localization methods, a program under test, which is unrolled to a certain bound, is encoded in a trace formula (TF). The efficiency and precision of the fault localization algorithm depend highly on the way this formula is encoded. The full flow-sensitive TF can cover all potential root causes, but is usually large and scalability problems remain. We propose a new encoding, the hardened flow-sensitive trace formula (HFTF), which reduces the complexity of the formula but does not lose essential control flow graph (CFG) information required for localizing faults. The HFTF is constructed using a concolic execution method that generates both failing and successful executions and uses the coverage information from these executions to simplify the trace formula.

We describe a tool to analyze unlinked documents by visualizing networks extracted using textual analysis. Our focus is on developing an interactive visual analytics tool that enables a user to interactively observe data to detect features of the documents that may be known or unknown in advance. We have tested our tool using two data sets, one consisting of 1000 documents and the other of 360 documents. The resulting visualization showed that our tool provides a simple yet powerful method to identify trends and to find facts in the documents quickly due to its interactivity.

We present a numerical optimization-based method for visualizing undirected graphs. Our method is a variant of force-directed graph drawing, and has sufficient generality to adopt different basic force models including those for the Kamada-Kawai and Fruchterman-Reingold methods. To achieve efficiency, we use the L-BFGS method for numerical optimization. Our experimental results show that the method gives good performance when combined with the Kamada-Kawai model.

We present an interactive tool for the exploratory analysis of a long-term video from a stationary camera. The tool consists of three key methods: spatial change visualization, temporal change visualization, and similarity-based video retrieval. The first two methods provide the summarization of the long-term video that lets the user know where and when changes frequently occurred during a certain period, enabling the user to find an event of interest from the long-term video. In addition, with the third method, the user can search the video for a similar event, enabling the user to count events of interest and to observe distributions of such events. These methods are uniformly implemented using frame differences in 1-bit depth, making the implementation of these methods simple but efficient.

We propose a scalable algorithm called HiRise2 for incrementally solving soft linear constraints over real domains. It is based on a framework for soft constraints, known as constraint hierarchies, to allow effective modeling of user interface applications by using hierarchical preferences for constraints. HiRise2 introduces LU decompositions to improve the scalability of an incremental simplex method. Using this algorithm, we implemented a constraint solver. We also show the results of experiments on the performance of the solver.

Constraints provide an effective means for the high-level modeling and reasoning of various problems. In particular, soft constraints are useful since they treat over-constrained problems that naturally arise in real-life applications. Therefore, researchers have been exploring frameworks for soft constraints. The framework of semiring-based constraint satisfaction problems (CSPs) can express many kinds of soft constraints such as weighted CSPs and fuzzy CSPs. The framework of constraint hierarchies emphasizes hierarchical preferences of soft constraints. Although semiring-based CSPs are known to be considerably general, it has been unclear whether they can express constraint hierarchies. In this paper, we show that a reasonable class of constraint hierarchies can be regarded as an instance of semiring-based CSPs.

We present several innovative interaction techniques for 3D target acquisition and indication. These techniques make use of the shape of our cylindrical multi-touch interface, which we are developing as an interface for a volumetric display. Our interaction techniques are used to control a spherical cursor in 3D space. Notably, our techniques use a two-handed operation in which the position and size of the area touched is mapped directly to the position and size of the spherical cursor. This mapping can instantly determine the 4DOF of the spherical cursor, i.e., its 3D coordinates and its radius, and thus allows rapid 3D target acquisition and indication.

Constraints have been playing an important role in the user interface field since its infancy. A prime use of constraints in this field is to automatically maintain geometric layouts of graphical objects. To facilitate the construction of constraint-based user interface applications, researchers have proposed various constraint satisfaction methods and constraint solvers. Most previous research has focused on either local propagation or linear constraints, excluding more general nonlinear ones. However, nonlinear geometric constraints are practically useful to various user interfaces, e.g., drawing editors and information visualization systems. In this paper, we propose a novel constraint solver called Chorus, which realizes various powerful nonlinear geometric constraints such as Euclidean geometric, non-overlapping, and graph layout constraints. A key feature of Chorus is its module mechanism that allows users to define new kinds of geometric constraints. Also, Chorus supports "soft" constraints with hierarchical strengths or preferences (i.e., constraint hierarchies). We describe its framework, algorithm, implementation, and experimental results.