Showing papers in "Journal of Visual Languages and Computing in 1995"

Layout Adjustment and the Mental Map

Abstract: Many models in software and information engineering use graph representations; examples are data flow diagrams, state transition diagrams, flow charts, PERT charts, organization charts, Petri nets and entity-relationship diagrams. The usefulness of these graph representations depends on the quality of the layout of the graphs. Automatic graph layout, which can release humans from graph drawing, is now available in several visualization systems. Most automatic layout facilities take a purely combinatorial description of a graph and produce a layout of the graph; these methods are called 'layout creation' methods. For interactive systems, another kind of layout is needed: a facility which can adjust a layout after a change is made by the user or by the application. Although layout adjustment is essential in interactive systems, most existing layout algorithms are designed for layout creation. The use of a layout creation method for layout adjustment may totally rearrange the layout and thus destroy the user's 'mental map' of the diagram; thus a set of layout adjustment methods, separate from layout creation methods, is needed. This paper discusses some layout adjustment methods and the preservation of the 'mental map' of the diagram. First, several models are proposed to make the concept of 'mental map' more precise. Then two kinds of layout adjustments are described. One is an algorithm for rearranging a diagram to avoid overlapping nodes, and the other is a method aimed at changing the focus of interest of the user without destroying the mental map. Next, some experience with visualization systems in which the techniques have been employed is also described.

Graph Drawing by the Magnetic Spring Model

Abstract: A novel and heuristic method for drawing graphs is proposed, introducing a new model called the magnetic spring model , that is an extension of the model by Eades. Graph drawing by force-directed placement has mainly been investigated so far for undirected graphs, and the idea of controlling edge orientations has not been considered. The proposed method can control orientations of links and can nicely draw not only undirected graphs but also other classes of graphs such as trees, directed graphs and mixed graphs in a simple and unified manner. Moreover, since the method is based upon simulations of physical systems, it is conceptually intuitive and therefore quite easy to understand, implement and improve the method. The magnetic spring model and algorithm are presented and many examples of drawings and results from statistical experiments are shown to demonstrate the effectiveness of the proposed method.

An Engine for the 3D Visualization of Program Information

Abstract: We have a project currently underway that attempts to use 3D workstations to provide insight into programs, their structure and their execution, through the use of a variety of user-definable displays. We offer a variety of different presentation styles and utilize a variety of different layout methods and heuristics. This paper describes the underlying engine that we have developed to support this range of presentations.

A Pictorial Query-By-Example Language

Abstract: A symbolic image is an array representing a set of objects and a set of spatial relations among them. Symbolic images and related structures have been used in a number of applications including image databases, spatial reasoning, path planning and spatial pattern matching. In this paper we describe a pictorial query-by-example (PQBE) language aimed at the retrieval of direction relations from symbolic images. As in the case of verbal query-by-example, PQBE generalizes from the example given by the user, but, instead of having queries in the form of skeleton tables showing the relation scheme, we have skeleton images which are themselves symbolic images. PQBE provides an intuitive interface for use in geographic applications because of its close correspondence with the structure of space.

SUPER: Visual Interfaces for Object + Relationship Data Models

Abstract: SUPER is an exploratory project into the next generation of user-DBMS interfaces. Its main objective is to demonstrate that a visual paradigm can lead to powerful and user-friendly interfaces supporting all phases of the database life cycle (i.e. creation, manipulation and evolution). Visual interaction in SUPER is based on direct manipulation of objects and functions, with a special focus on providing users with maximum flexibility and independence from database technicalities. The set of tools offers facilities to meet the varied demands from categories of users with different levels of skill. Diagrammatic representations and a basic set of functions are better suited for novice and occasional users, while menus and dialog boxes speed up the dialog for expert users. At the same times a consistent interaction style over the various functions and tools has been emphasized. SUPER has been designed as a front end to a relational or an object-oriented DBMS, i.e. the persistence of data, consistency and concurrency problems are delegated to an off-the-shelf database management system. The current prototype supports schema definition, query formulation and browsing using a powerful data model based on objects and relationships.

Comparing and Evaluating Layout Algorithms within GraphEd

Abstract: Graph drawing and layout algorithms are gaining growing interest and importance for the visualization of complex data structures. But, despite many algorithms and concepts, there is no satisfactory solution to the central problem of the criteria for good and readable layouts. We approach this problem and evaluate layout algorithms by comparing their effect on a large set of sample graphs. In each run we compute statistical data which is collected and evaluated. Our experiments show that traditional layout criteria, such as minimal area or maximal edge length or straight line edges, are not as important as they may appear. Balance is often better than optimization, and displaying the intended and inherited structure of a graph is often more important than these formal cost criteria.

Syntax and Semantics of Gql, a Graphical Query Language

Abstract: The problem of formalization for visual languages has been identified as an important one. We present in this paper a formal definition of both the syntax and semantics of Gql, a declarative graphical query language based on the functional data model. In Gql a query is fully and unambiguously represented by a single diagram and the user interaction is kept distinct from the language itself. In our approach for formalization we abstract from the world of graphics and concentrate on a world of sets and functions, called the base structure, which represent the various elements of the language. The syntactical definition of the language is completed by defining a set of rules that a base structure instance must satisfy, in order for it to correspond to a legal Gql query. The semantics of the language is given via a functionally defined, syntax-directed translation from Gql queries (represented as base structure instances) to list comprehensions. Finally, a form of attribute grammar is used in conjunction with the previous definitions for specifying in a single formalism both the syntax and semantics of Gql.

Toward a Theory of Active Index

Abstract: This paper introduces a theoretical framework for the active index. The active index facilitates the accessing and automatic manipulation of visual objects. With an active index, we can effectively and efficiently handle smart images that respond to accessing, probing and other actions. Another important application is information retrieval in hyperspace. The active index can also be used to realize Petri nets, generalized Petri nets such as G-nets, B-trees, etc., but the dynamic nature of the active index is its most important characteristic. Implementation considerations and research issues are discussed.

A High Level Interface Language for GIS

Abstract: This paper presents a graphical query language for Geographic Information Systems, called Cigales. The basic idea of this language is to express a query by drawing a pattern corresponding to the results the user wants to be displayed. This drawing is in accordance with the user's representation of the real world. A set of active icons models graphical forms. These graphical forms are the representation of geometric objects such as line, area, and operations such as inclusion, intersection… The graphical query is then translated into a functional language. This intermediate language guarantees the independence of Cigales from the Data Management System. The user does not worry about physical storage of data and does not have to learn a new language. The functional expression is optimized and translated into specific Data Management System orders (i.e. extended SQL). This paper also describes an extended SQL of a geographic DBMS which was used as a first platform for the implementation of Cigales. The advantages and limits of using a graphical approach is then analysed.

Queries in an Object-Oriented Graphical Interface

Abstract: The graphical user interface OdeView for the Ode object-oriented database system allows users to perform complex operations against sets of objects. These include selection, projection, display, creation, deletion and update of objects, and the invocation of member functions (methods). OdeView utilizes type information for displaying objects and the relationships between objects, and for guiding the user in constructing syntactically correct query predicates. We present a formal model that underlies the OdeView display and query interface, illustrate the graphical query facilities through examples, and discuss our design decisions. We also describe our implementation, focusing on the usage of the Ode type catalog and the dynamic translation and execution of queries. As object database systems are becoming increasingly popular, we hope that the design and implementation details provided in this paper will benefit those interested in building graphical interfaces to database systems, particularly object-oriented database systems.

Randomized Graph Drawing with Heavy-Duty Preprocessing

Abstract: We present a graph drawing system for general undirected graphs with straight-line edges. It carries out a rather complex set of preprocessing steps, designed to produce a topologically good, but not necessarily nice-looking layout, which is then subjected to a downhill-only version of Davidson and Harel's simulated annealing beautification algorithm. The intermediate layout is planar for planar graphs and attempts to come close to planar for non-planar graphs. The system's results are better and faster than what the annealing approach is able to achieve on its own.

Mapgets: A Tool for Visualizing and Querying Geographic Information

Abstract: Although geographic applications vary widely, their user interfaces have many requirements in common because of the spatial component of their data Geographic data are not standard data, and appropriate tools are required (i) for editing (ie displaying and modifying) and (ii) for querying them In this paper, we first study the major aspects of visualizing and querying geographic information within a database management system (DBMS) and their impact on the design of graphical geographic database user interfaces (GDUIs) We then present a map editing and querying model as well as general GDUI architecture Both rely on the concept of the mapget (map widget), a mediator for manipulating geographic information interactively

Detecting Cuts by Understanding Camera Operations for Video Indexing

Abstract: The emergence of multimedia information, such as video, has presented a problem to traditional information management systems which were not designed to handle media other than standard alphanumeric data. To handle a continuous media such as video, one should segment it into basic units to be used for identification and indexing. The main problem in most existing techniques for locating the boundaries between the basic units or scenes is the selection of thresholds with which the interframe differences are compared. Various changes might happen within a single scene, which include changes occurring as a result of camera operations, object movements, flashes, etc. On the other hand, various similarities between different scenes might occur. Therefore, selection of any threshold value will result in low detection rates due to detecting false cuts or missing true cuts. In this paper we propose a detection mechanism that understands and detects various changes within a scene in order to detect the cuts between different scenes. These cuts may represent sharp or gradual cuts. This mechanism depends on the hue value flow generated as a result of camera operations, object movements or cuts.

A Hypergraph-based Framework for Visual Interaction with Databases

Abstract: The advent of graphical workstations has led to a new generation of interaction tools in database systems, where the use of graphics greatly enhances the quality of the interaction. Yet, Visual Query Languages present some limitations, deriving partly from their own paradigm and partly from the available technology. One of the basic drawbacks is the lack of formalization, in contrast to the well-established traditional languages. In this paper we propose a theoretical framework for visual interaction with databases, having a particular kind of hypergraph, the Structure Modeling Hypergraph (SMH), as a representation tool, able to capture the features of existing data models. SMHs profit from the basic property of diagrams while overcoming their limitations. Notable characteristics of SMHs are: uniform and unified representation of intensional and extensional aspects of databases, direct representation of containment relationships, and immediate applicability of direct manipulation primitives. SMHs are not a new data model but a new representation language that provides the syntactic rules for describing the structuring mechanisms of data models. SMHs can be queried by formal systems closed under queries.

A Visual Dataflow Programming Environment for a Real Time Parallel Vision Machine

Abstract: Programming parallel architectures dedicated to real-time image processing (IP) is often a difficult and error-prone task. This mainly results from the fact that IP algorithms typically involve several distinct processing levels and data representations, and that various execution models as well as complex hardware are needed for handling these processing layers under real-time constraints. Our goal is to permit an intuitive but still efficient handling of such an architecture by providing a continuous and readable path from the functional specification of an algorithm to its corresponding hardware implementation. For this, we developed a data-flow programming model which can act simultaneously as a functional representation of algorithms and as a structural description of their corresponding implementations on a target computer built up of 3-D interconnected data-driven processing elements (DDPs). Algorithms are decomposed into functional primitives viewed as top-level nodes of a data-flow graph (DFG). Each node is given a known physical implementation on the target architecture, either as a single DDP or as an encapsulated sub graph of DDPs, making the well known mapping problem a topological one. The target computer was built at ETCA and embeds 1024 custom data-driven processors and 12 transputers in a 3-D interconnected network. Concurrently with the machine, a complete programming environment has been developed. Relying upon a functional compiler, a large library of IP primitives and automatic place-and-route facilities, it also includes various X-Window based tools aiming at visual and efficient access to all intermediary program representations. In terms of visual languages, we try to share the burden between all the layers of this programming environment. Rather than including some display facilities in existing software environment, we have taken advantage of the intuitiveness of functional representations, even textual, and of the hardware efficiency that provides immediate results, ultimately supporting hierarchical constructs.

Guest editors' foreward

Abstract: This issue of JLAP is devoted to selected papers from the conference on Foundations of Software Science and Computation Structures 2006 (FOSSACS 2006). The conference took place in Vienna in the period 29–31 March 2006 as part of the European Joint Conferences on Theory and Practice of Software (ETAPS), which is the primary European forum for academic and industrial researchers working on topics relating to software science. The FOSSACS conference series is devoted to the presentation of original papers on foundational research with a clear significance for software science. The six papers in this volume reflect the breadth and quality of FOSSACS 2006. They explore different areas of research in the theoretical underpinnings of software science, contributing new results on a denotational understanding of hybrid automata (Edalat and Pattinson), on behavioural theories of fault tolerance in computation (Francalanza and Hennessy), on dynamic logics of programs (Löding, Lutz and Serre), on reversible computation (Phillips and Ulidowski), on coalgebraic studies of modal logics (Schroeder) and on a logic for describing reachable patterns in linked data structures (Yorsch et al.). We thank the colleagues who submitted papers to the special issue, the expert referees who devoted their time and effort to the evaluation of the submissions and all of the participants in the conference for their contributions to the meeting and to the special issue. Moreover, we thank Jens Knoop, the chair of the organizing committee for ETAPS 2006, and his colleagues for their tireless organizational assistance at all times.