Gareth Griffith

The Observer and the Orthographic Projection

We now address the problem of representing views of three-dimensional scenes on the graphics viewport. There are three major stages. In chapter 7 we saw how to construct a model of a three-dimensional scene in ACTUAL position. In this chapter we consider observing the scene and the display of a corresponding view. The display of the scene is co-ordinated by routine drawit which may take a number of different forms, depending on the type of image required (line drawing, colour etc). This routine will be called at the end of the scene routine after the construction of the model and the positioning of the observer. We shall deal with the observer before going on to consider the drawit display.

Familiarisation with Programs, Graphics Devices and Primitives

Computer graphics devices come in all shapes and sizes: storage tubes, raster devices, vector refresh displays, flat-bed plotters etc., which is why in recent years so much effort has been put into graphics software standards (such as G.K.S. (Hopgood et al., 1983)) as well as into the portability of graphics packages (GINO, CalComp etc.). This book will concentrate on the techniques of modelling and rendering (that is, drawing, colouring, shading etc.) two-dimensional and three-dimensional objects, which surprisingly require only a small part of the above systems. Rather than restrict ourselves to one software system, and in order to make this book relevant to as many different graphics devices as possible, we will identify a general model for a graphics device together with a few (nine) elementary routines (primitives) for manipulating that model. From the outset it must be realised that we are using the word ‘primitive’ in the literal sense of describing the basic level at which the programs in this book communicate with graphics devices; the word has different meanings in other graphics environments, such as G.K.S. The Pascal programs that follow will use only these primitives for drawing on this basic model (apart from a few very exceptional cases). Since even the most complex programs given in this book interface with the model device through relatively few primitive routines, the graphics package we create is readily portable.

Generation of Model Data

The previous chapter introduced our method for constructing and drawing scenes: a function build_it is used to construct data about a three-dimensional scene via construction functions, some input from file. Then the vertices are transformed into the OBSERVED position, clipped, projected by project_it, and the function draw_it is called to display the final scene. In the following chapters we will give a number of different types of draw_it and facet display functions, that depend only on the projection and type of picture you require: line drawing, colour with/without shading, shadows etc. All the reader need do is to create the relevant application program consisting of build_it and construction functions and set up the required draw_it function in “display.cpp”; the rest is done for you in our use of the Borland C++ Project by linking in files “construc.cpp”, “model.cpp”, “window.cpp”, “display.cpp” and “ClusterA(BCDEFGH&I).cpp”.

Techniques for Manipulating Two-dimensional Objects

The methods introduced so far enable us to create and draw a simple representation of any two-dimensional scene consisting of a set of vertices, lines and polygonal facets. In this chapter we shall consider a number of techniques which may be used for more complex pictures of two-dimensional scenes along with some which we will need when developing algorithms to deal with three-dimensional solid models. Naturally these functions must be #included into complete programs at positions that ensure a valid scope.

Analytic Representation of Three-dimensional Space

In this chapter we shall discuss an exciting recent development in the representation of objects in three-dimensional space. We take a totally different approach to the definition of a scene: instead of approximating surfaces with a polygonal mesh, we define them as combinations of primitive objects. Each primitive object is mathematically defined in terms of an analytic function: we have already introduced this idea in the analytic representation of surfaces in chapter 6. This approach allows a very simple definition of many scenes, but the ease of definition has to be paid for with a large increase in processing overheads, although not necessarily in program complexity. To illustrate these ideas we look at two implementations. The first, the quad-tree (Sidhu and Boute, 1972; Tanimoto, 1977; Hunter and Steiglitz, 1979; Woodwark, 1984), will be used to draw simple molecular models composed of a grouping of spheres of arbitrary radius and position. A program, using listings 1.1, 1.3, 3.3,7.1 and 8.1 linked to the draw-a_picture function of listing 17.1 is used to illustrate it. Apart from the #included file ‘matrix3.c’, also required are transform (listing 7.2), find Q, look 3 (listing 8.1), insource (listing 15.1), findlogicalcolour and colourtable (listing 15.10), and cshade (listing 15.9). Secondly there is the oct-tree method (Clark, 1976; Meagher, 1982): we do not give a program but outline the method and also describe the construction of a binary tree defining a scene as the union, intersection and complement of various primitives. (Such a description can also be used with ray-tracing and the quad-tree method.)

Three-dimensional Clipping

In chapter 5 we considered the clipping of lines and facets in two-dimensional space, determining which parts lay within a rectangular window with dimensions horiz × vert. These methods are also sufficient for dealing with orthographic projections of three-dimensional scenes since the whole of space can be projected onto the view plane and clipped in two dimensions. Dealing with perspective projections is rather more complex. Once again we assume that we have a view plane some distance from the eye along the negative z-axis of the right-handed OBSERVER system. A rectangular (horiz × vert) window on this plane is to be identified with the graphics viewport. In previous chapters we have assumed that the eye is positioned in such a way that each vertex has a strictly negative OBSERVED z co-ordinate. This ensures that every vertex can be projected onto the view plane by a standard perspective projection as defined in chapter 11, whence two-dimensional clipping ascertains which parts of the image lie totally within the window. Suppose, however, that we wish to depict a scene as viewed from a position within the model, such as a point lying in a landscape with a large ground plane. Clearly, parts of the model will lie behind the eye and consequently cannot be projected onto the view plane. Such problems cannot be resolved by two-dimensional clipping and so extended methods must be developed. Three-dimensional clipping must determine which parts of a line or facet can be projected onto the window before the projection occurs.

Familiarisation with Graphics Devices and Primitives

Computer graphics devices come in all shapes and sizes: storage tubes, raster devices, vector refresh displays, flat-bed plotters etc., which is why in recent years so much effort has been put into graphics software standards (such as G.K.S. (Hopgood et al., 1983)) as well as into the portability of graphics packages (GINO, CalComp etc.). This book will concentrate on the techniques of modelling and rendering (that is, drawing, colouring, shading etc.) two-dimensional and threedimensional objects, which surprisingly require only a small part of the above systems. Rather than restrict ourselves to one software system, and in order to make this book relevant to as many different graphics devices as possible, we will identify a general model for a graphics device together with a few (nine) elementary routines (primitives) for manipulating that model. From the outset is must be realised that we are using the word ‘primitive’ in the literal sense of describing the basic level at which the programs in this book communicate with graphics devices; the word has different meanings in other graphics environments, such as G.K.S. The FORTRAN 77 programs that follow will use only these primitives for drawing on this basic model (apart from a few very exceptional cases). Since even the most complex programs given in this book interface with the model device through relatively few primitive routines, the graphics package we create is readily portable. All that is needed is for users to write their own device-specific primitives, which relate to their particular graphics device or package! Later in this chapter we give ideas of how such primitives may be written, and in the appendix there are example listings of primitives suitable for some of the more popular graphics devices and standards.

Simple Hidden Line and Surface Algorithms

We are now able to draw wire diagrams representing any scene. We would like, however, to consider solid objects, in which case the facets at the front will obviously restrict the view of the facets (and boundary lines) at the back. In order to produce such a picture we must introduce an algorithm which determines which parts of a surface or line are visible and which are not. Such algorithms are called hidden surface or hidden line algorithms, depending upon their purpose. There are many of these algorithms, some elementary for specially restricted situations, others very sophisticated for viewing general complicated scenes (Sutherland et al., 1974). In this book we shall consider a variety of approaches ranging from the very simplest types in this chapter, to examples of general-purpose algorithms in chapters 12 and 13.