GeoPrO Description 

Overview

The GeoPrO environment is a system intended to provide distributed visualization for computational geometry applications as well as to serve as a tool for teaching computational geometry. Currently, it supports only 2 dimensional data. The geometric objects are represented, by the Geometric Description Protocol (GDP), by means of points with 2 dimensional signed homogeneous coordinates, thus, fully supporting the Oriented Projective Geometry (OPG) [5][6].

 Roughly, it comprises a kernel program (the server), that holds the geometric data in multiple contexts, and programming interfaces, that allow the implementation of programs able to connect to the kernel through client/server Internet TCP/IP channels. There are two types of clients: the applications and the visualizers. Their scope is a single context, not the whole kernel. There may be many clients connected to a context, whereas a client can be connected to only one context. For instance, in a classroom, many students may visualize the same data in distinct visualizers running on different machines by connecting to the same context. A context is essentially a collection of two types of information: objects and requests. Usually, applications insert and remove objects from the context they are connected to and visualizers receive one copy of each object and may render them according to its own features. In addition to this basic visualization procedure, the environment allows the visualizers to work as sources of objects. One application may insert a request in the context for an object of a specific type. All the visualizers connected to that context may respond to the request. As an example, an application inserts in the context a request for a set of points. A user enters the points with the interface of some visualizer and then respond to the request. The application will receive a copy of the object and may, for instance, construct the Convex Hull of the set of points and insert it in the context as a set of line segments (see the sample image).

 The clients communicate with the kernel with a fixed set of messages like: "insert the object x" or "respond to the request y". The environment uses the XDR [8] protocol to encode the basic data types in the messages. This allows the implementation of applications and visualizers for different architectures. Moreover, the use of the TCP/IP protocol makes possible the distributed visualization over an heterogeneous network. 

The Kernel

The kernel is an interface-less program written in C++ that holds the data and accepts connections from applications and visualizers. It has four major classes: an application catalog; a visualizer catalog; a context catalog and an event handler. Each application or visualizer entry in the corresponding catalog has a pointer to a context entry in the context catalog. Each context entry has two other catalogs: an object catalog and a request catalog. The event handler basically "listens" to the socket channels for new connections and to existing connections for new messages.

 

The Application Interface

The application interface is a class available in C++ and JAVA that allows the implementation of programs able to connect to the kernel through the Internet. An application can send the following messages to the kernel: The kernel can send the following message to and application: We have implemented some computational geometry algorithms as GeoPrO applications. Take a look at the sample images in the main page. 

The Visualizer Interface

The visualizer interface is also available in C++ and JAVA. A visualizer can send the following messages to the kernel: The kernel can send the following message to and visualizer: We have implemented two visualizers for the GeoPrO: the sphereView and the flatModel. The sphereView renders the objects in the spherical model of the OPG. It is a passive visualizer, in the sense that it only shows the objects and, therefore, cannot answer to an request. Nevertheless, this model provides the most interesting geometric intuition about the OPG. The flatModel visualizer renders the objects in the two-sided plane model of the OPG. It allows the user to enter the basic objects with the mouse much like a "graphic editor". Both visualizers are written in C++ and use the OpenGL Graphic Library [7] for basic graphic rotines. Take a look at the sample images in the main page 

The Geometric Description Protocol

All the objects in the GeoPrO environment are described by a fixed set of basic objects. The basic objects are: These objects are all represented by 2 dimensional points with signed homogeneous coordinates. For instance, a line segment is represented by its endpoints and a line by two distinct points on it. The conic and conic arcs are represented, respectively, by 3 and 5 points as described in [4]. The protocol also specifies the non-geometric object group, to allow easy manipulation of more complex geometric structures like planar subdivisions. 

The JAVA Kernel Manager

The kernel also accepts connections from a third type of client: the manager. It was implemented in JAVA and provides full control of the kernel to an administrator. Its interface presents all the active clients and contexts of the kernel. The administrator can open a context and view all its active objects and requests.

 

He can (among other things):

Current and Future Work

We are currently working on: We plan to migrate all the environment to JAVA as soon as it becomes a standarized language. The design of the GeoPrO kernel fits perfectly the features of that programming language. Moreover, the portability of the system would be greatly improved.

 

gap

Last modified: Sun Sep 28 17:18:50 EST 1997