Detection and typification of linear structures for dynamic visualization of 3D city models

Cluttering is a fundamental problem in 3D city model visualization. In this paper, a novel method for removing cluttering by typification of linear building groups is proposed. This method works in static as well as dynamic visualization of 3D city models. The method starts by converting building models in higher Levels of Details (LoDs) into LoD1 with ground plan and height. Then the Minimum Spanning Tree (MST) is generated according to the distance between the building ground plans. Based on the MST, linear building groups are detected for typification. The typification level of a building group is determined by its distance to the viewpoint as well as its viewing angle. Next, the selected buildings are removed and the remaining ones are adjusted in each group separately. To preserve the building features and their spatial distribution, Attributed Relational Graph (ARG) and Nested Earth Mover’s Distance (NEMD) are used to evaluate the difference between the original building objects and the generalized ones. The experimental results indicate that our method can reduce the number of buildings while preserving the visual similarity of the urban areas.     

Conversations of objects

An increasing range of application systems implemented in concurrent object oriented languages (COOLs) creates a pressing demand for developing approaches which provide a systematic way of tolerating software and hardware faults by using software diversity. This paper deals with the problem of tolerating faults in concurrent systems of this type. The purposes of this paper are as follows: to discuss the most appropriate ways of implementing conversations in COOLs; to map all attributes of conversations onto these languages; to discuss the most relevant peculiarities of COOLs in these terms; to suggest approaches to using the conversation scheme; to find the ways in which characteristics of COOLs can facilitate the use of conversation schemes. Thus we try to show how conversations can be used in existing COOLs in a more practical and realistic manner.     

Conversations of objects

An increasing range of application systems implemented in concurrent object oriented languages (COOLs) creates a pressing demand for developing approaches which provide a systematic way of tolerating software and hardware faults by using software diversity. This paper deals with the problem of tolerating faults in concurrent systems of this type. The purposes of this paper are as follows: to discuss the most appropriate ways of implementing conversations in COOLs; to map all attributes of conversations onto these languages; to discuss the most relevant peculiarities of COOLs in these terms; to suggest approaches to using the conversation scheme; to find the ways in which characteristics of COOLs can facilitate the use of conversation schemes. Thus we try to show how conversations can be used in existing COOLs in a more practical and realistic manner.     

Mapping objects

We present a technique that is based on volatile mapping objects and enables wrappers-based mediation architectures to describe bi-directional (read–write) interschema mappings of multiple, disparate data sources. We describe the structure of these mapping objects, explain how they work, and compare them to other traditional techniques used for describing schema mappings in data-mediation systems.     

Graphical objects

We introduce the concept of graphical objects, the abstraction paradigms to study them, and their applications in computer graphics. Intuitively, graphical objects encompass all the entities manipulated in a graphics system. This notion makes it possible to unify similar research topics appearing in the literature separately. We study the problem of object metamorphosis, which includes the problem of image metamorphosis. Although we are not primarily concerned with implementation issues in this paper, the concepts we introduce can be exploited for system design and development that use object-oriented programming.     

Mock objects

One thing that makes unit-testing code so hard is the way the real world keeps intruding. If all we had to do was code up tests for methods that sort arrays or generate Fibonacci series, life would be easy. In the real world we have to test code that uses databases, communications devices, user interfaces, and external applications. We might have to interface to devices that are not yet available or simulate network errors that are impossible to generate locally. This all conspires to stop our unit tests from being neat, self-contained (and orthogonal) chunks of code. Fortunately there is a testing pattern that can help. The authors consider the use of mock objects. With mock objects you can test code in splendid isolation, simulating all those messy real-world things that would otherwise make automated testing impossible. As with many other testing practices, the discipline of using mock objects can improve your code's structure     

Total objects of domains

The main result of this paper is a characterization of the space induced by Scott topology on the set of total objects of a bounded-complete cpo. This characterization is simple with bounded-complete algebraic cpo's where a family of clopen sets plays an essential role in the characterization. In the more general case of continuity, one can only produce distinct families of open sets and closed sets to axiomatize the essential properties of a total space. Besides the main characterization, we also discuss its relation to continuous spaces, studied in our earlier paper, and the relation between compact T spaces and total spaces under the lower topology.     

Illumination of image-based objects

A new data representation of image-based objects is presented. With this representation, the user can change the illumination as well as the viewpoint of an image-based scene. Physically correct imagery can be generated without knowing any geometrical information (e.g. depth or surface normal) of the scene. By treating each pixel on the image plane as a surface element, we can measure its apparent BRDF (bidirectional reflectance distribution function) by collecting information in the sampled images. These BRDFs allow us to calculate the correct pixel colour under a new illumination set-up by fitting the intensity, direction and number of the light sources. We demonstrate that the proposed representation allows re-rendering of the scene illuminated by different types of light sources. Moreover, two compression schemes, spherical harmonics and discrete cosine transform, are proposed to compress the huge amount of tabular BRDF data. © 1998 John Wiley & Sons, Ltd.     

Dynamic superimposition of synthetic objects on rigid and simple-deformable real objects

A current challenge in augmented reality applications is the accurate superimposition of synthetic objects on real objects within the environment. This challenge is heightened when the real objects are in motion and/or are non-rigid. In this article, we present a robust method for real-time, optical superimposition of synthetic objects on dynamic, rigid and simple-deformable real objects. Moreover, we illustrate this general method with the VRDA Tool, a medical education application enabling the visualization of internal human knee joint anatomy on a real human knee.     

Distributed logic objects

This paper presents a language based on the logic programming paradigm that supports objects, messages and inheritance. The object-oriented extension is fairly simple: objects are clusters of processes, objects' state is represented by logical variables, message-passing communication between objects is performed via multi-head clauses, and inheritance is mapped into clause union. The language implementation is obtained by translating logic objects into a concurrent logic language based on multi-head clauses, taking advantage of its distributed implementation on a massively parallel architecture. The runtime support realizes some interesting features such as intensional messages and the transparency of object allocation, object migration and parallelism.     

Classifying dynamic objects

For robots operating in real-world environments, the ability to deal with dynamic entities such as humans, animals, vehicles, or other robots is of fundamental importance. The variability of dynamic objects, however, is large in general, which makes it hard to manually design suitable models for their appearance and dynamics. In this paper, we present an unsupervised learning approach to this model-building problem. We describe an exemplar-based model for representing the time-varying appearance of objects in planar laser scans as well as a clustering procedure that builds a set of object classes from given observation sequences. Extensive experiments in real environments demonstrate that our system is able to autonomously learn useful models for, e.g., pedestrians, skaters, or cyclists without being provided with external class information.     

Detecting moving objects

The detection of moving objects is important in many tasks. This paper examines moving object detection based primarily on optical flow. We conclude that in realistic situations, detection using visual information alone is quite difficult, particularly when the camera may also be moving. The availability of additional information about camera motion and/or scene structure greatly simplifies the problem. Two general classes of techniques are examined. The first is based upon the motion epipolar constraint—translational motion produces a flow field radially expanding from a focus of expansion (FOE). Epipolar methods depend on knowing at least partial information about camera translation and/or rotation. The second class of methods is based on comparison of observed optical flow with other information about depth, for example from stereo vision. Examples of several of these techniques are presented.A preliminary version of this article appeared in The Proceedings of the First International Conference on Computer Vision, London, June 1987.     

External relationships of objects

External relationships of objects represent semantic dependencies between objects that enable inter-object communication and augment the services the objects provide with role-specific behaviors. Most of the object-oriented design methodologies support the notion of external relationships at the conceptual level, but OO programming languages have no language construct to directly implement the external relationships, which are implemented as containment relationships with embedded pointers resulting in the semantics of the relationships being buried in code. Moreover, object-oriented programming languages lack a mechanism to allow a dynamic classification of objects according to the roles they play in external relationships. This paper describes a technique to treat an external relationship as a conceptually useful abstraction at the specification stage and a separately identifiable structure at the implementation stage, by providing a declarative specification and an implementation in C++ with special focus on the implementation of object roles. © 1998 John Wiley & Sons, Ltd.     

Cyclic twill-woven objects

Classical (or biaxial) twill is a textile weave in which the weft threads pass over and under two or more warp threads, with an offset between adjacent weft threads to give an appearance of diagonal lines. This paper introduces a theoretical framework for constructing twill-woven objects, i.e., cyclic twill-weavings on arbitrary surfaces, and it provides methods to convert polygonal meshes into twill-woven objects. It also develops a general technique to obtain exact triaxial-woven objects from an arbitrary polygonal mesh surface.     

Bending polyhedral objects

A geometric algorithm for performing bending operations on polyhedral objects is described. The hypotheses, conditions and model of the bending process are defined, and then the mathematical model of bending is developed for each element of the boundary representation of a polyhedron. The algorithm has applications as a new means of generating geometric models and, in the CAD/CAM field, for simulating bending processes used to manufacture parts. The algorithm has been implemented and examples are given of objects transformed by the bending operation.     

Recovering distributed objects

Distributed multithreaded applications operating in shared-nothing environments present challenges to classical fault tolerance mechanisms. The piecewise determinism assumption is lost (due to multithreading), and data must be replicated (because of the shared-nothing environment). In this paper, we explore a systematic approach to providing fault tolerance, by considering data-race-free programs that have the benefits of piecewise determinism and yet allow multithreading. We base our logging and recovery algorithm on a logical ring structure that allows the underlying distributed system to migrate threads, migrate and replicate objects, and perform multi-object transactions.