Download Segments on bit mapped graphics displays

SOFTWARGPRACTICE AND EXPERIENCE, VOL. 16 (1 l), 965-980 (NOVEMBER 1986)
Segments on Bit-mapped Graphics Displays
MEL SLATER
Department of Computer Science and Statistics, Queen Mary College, (University of
London), Mile End Road, London El 4NS, U.K.
SUMMARY
The problems associated with using picture segments in interactive applications on workstations
with bit-mapped displays are discussed. A method for displaying and updating segments is
introduced.
KEY WORDS
Segments
Display file
Bit-map
GKS
1. INTRODUCTION-PICTURE
SEGMENTS
Computer graphics packages which have their origins in the 1970s (or earlier) such as
GINO,’ CORE2 and GKS3,4provide picture segments as the means of defining and
manipulating separate components of an overall image. A picture segment is defined
as a group of graphical output primitives, such as lines, polygonal fill areas and text.
An output primitive is generated by a call to a graphical output function provided by
the package. For example, when a segment is created in GKS, subsequent calls to the
graphical output functions (such as Polyline, Fill Area and Text) are written to the
segment, until the segment is closed. The applications program provides a name for
each segment, which can then be used as a handle for manipulation.
A segment can be highlighted, made visible or invisible, or be transformed by an
affine transformation. This provides the means for creating an image in a structured
manner, made up of a number of separable parts. In addition, in an interactive system,
a segment can be picked-that is, a function is provided whereby a segment can be
identified and its name can be returned to the applications program. (This type of
input is called Pick Input in GKS). For example, an operator might use an input
device to point at a segment’s representation on the display, in order to identify a part
of the picture to be modified. Dragging can be achieved by repeatedly applying a
transformation which specifies a translation in accordance with the movement of a
cursor. These ideas are illustrated in Figures 1 and 2, which were created interactively
using GKS.
Such picture segments have historically been attractive in computer graphics because
of their direct correspondence to vector refresh display architecture. Here the image is
actually represented in the graphics device as a segmented display list of vectors.
0038-0644/86/110965-16~08.00
0 1986 by John Wiley & Sons, Ltd.
Received 18 September 1985
Revised 7 March 1986
966
M . SLATER
Fig. 1
I
Segments
1
x
Figure I . Segments: each image component is a single segment
are usually created
in applications p r o g r a m s
as follows:Createsegment( 1 ) ;
11'
CloseSegment
Polyline & Text
are 2 of the GKS
output primitives
Figure 2.
Segments in the device display list correspond exactly to the high-level segments
defined in an applications program. T h e refresh cycle involves cycling through the
display list, continually regenerating the screen image at a rate fast enough to give the
SEGMENTS ON BIT-MAPPED GRAPHICS DISPLAYS
967
impression of immediate changes to the picture. For example, the instruction to rotate
a segment would result in an immediate change in the orientation of the segment’s
screen representation.
This type of system and display architecture proves especially suitable for engineering
CAD applications, where technical drawings are composed of vectors (and charactersalso constructed from vectors). Changes to the drawing, such as repositioning, scaling
or rotating objects, can occur at a speed fast enough to allow a genuinely interactive
means of technical design.
Modern single-user workstations usually provide a bit-mapped graphics display,
where the screen is refreshed from a (rectangular) array of bits with one bit per pixel.
Graphics programming is based on a rasterop primitive which is a copy operation
combining a source rectangle with a destination rectangle according to a bit combination
rule. Functions are provided which allow easy construction of basic tools used in
interactive graphics-such as rubber-band techniques, pop-up menus and icons. Together with a suitable input device, such as a tablet and puck or mouse, such systems
attempt to provide a total computational environment. The original work carried out
at Xerox PARC resulting in Smalltalk-805@is the fundamental model for such systems.
Bit-mapped displays are very good indeed for manipulating images at the pixel and
rectangle level. However, the concept of a picture segment remains a valuable highlevel representation, corresponding to the way a graphics programmer might think
about how a picture is to be constructed. This is especially the case in CAD: pictures
are composed of vectors, and groups of vectors represent meaningful components which
are a basis for interactive manipulation. However, there is a conflict between the highlevel segment representation and the device architecture. T h e device stores a picture
as a bit-map, whereas a segment is a sequence of geometrically-defined graphics
primitives. The direct mapping between the picture description in terms of segments
and the device method of representing the screen image is totally lost.
As an example, the instruction to set segment S to be invisible would require a n .
identification of exactly those pixels corresponding to S. These pixels must be switched
o f , but pixels corresponding to other segments which might be near or overlap S must
not be affected. Obviously, this operation is computationally possible-but rather slow.
The use of segments on bit-mapped displays has been seen as equivalent to abandoning
the speed necessary for interaction with meaningful components of the picture. If a
segment cannot be dragged or rotated in real time, then it is no longer a means of
dynamic manipulation, but simply a data structure providing a high-level picture
description.
Graphics standards such as G K S insist on the segment as the basis of picture
construction, even though bit-mapped and raster displays are cheaper and in greater
use than the old-style vector refresh devices. Project managers faced with the conflicting
demands of using standards wherever possible and relying ‘on equipment which cannot
support graphics standards efficiently are left with a difficult choice, which sometimes
leads to the decision to abandon the graphics standards altogether.
The purpose of this paper is to show that it is possible to use segments on bitmapped devices in interactive applications. The objective is to provide an algorithm
which allows dynamic changes to bit-mapped displays, where segments are used as the
means of picture description. The algorithm must be as fast as possible.
@ Smalltalk-80 is a trademark of the Xerox Corporation.
968
M . SLATER
2.
DYNAMIC CHANGES ON BIT-MAPPED DISPLAYS
There are several responses to the problems associated with segments on bit-mapped
displays. The first is to ignore this approach altogether and construct algorithms and
software based on what these displays are especially good at-manipulating rectangles.
For example, Pike6 describes a toolkit based on (overlapping) rectangle primitives.
Cook7 describes an algorithm for fast movement of (overlapping) rectangular objects
(such as images of playing cards) around a display. The Smalltalk approach, based
essentially on rasterop and bitwise-governed graphics primitives (e.g. drawing lines
and curves using the Exclusive OR combination rule), has provided good-quality
graphics on bit-mapped displays. T h e drawback is that it is not possible in these
systems to escape from the essentially rectangular limitation, It is thus not possible to
achieve genuine scaling of an object (except by blowing up pixels) or rotation (except
through right angles). There is no possibility of defining and interacting with arbitrary
geometrical objects.
A second method for dealing with segments on bit-mapped displays is to treat
segments as a storage data structure only. This is the method implicit in G K S for
dealing with segments on devices which cannot perform dynamic modifications to an
image efficiently. When in such an interpretation a segment is, for example, rotated
by a call to the Transform Segment function, the screen image does not necessarily
immediately change to show the segment in its new orientation. In fact the effect of
the function is purely internal-the transformation matrix associated with the segment
is changed as required, and this new transformation is applied to the geometric
description of the primitives in the segment at the time when the image is next explicitly
updated by a call to the Update Workstation function. Immediate dynamic changes to
a display are not possible-except, of course, displaying new primitives. (GKS also
allows the system to be put into a state where the entire image is redrawn whenever a
dynamic change to the picture is flagged.) This method is clearly not suitable for
interactive work, since it involves redrawing the whole image based on the data in the
segment data structures whenever an update is required. For complex images, perhaps
involving thousands of vectors, the time involved is usually unacceptable.
A third method is to allow ‘dirty’ dynamic changes to a picture. Again segments act
as a storage data structure. When a segment attribute is changed (made invisible, or
transformed) the segment is redrawn using the Exclusive.OR or 0 combination rulewhich has the effect of deleting it from the screen. In the case of transformation it can
then be redrawn in its new position. This approach was adopted by Bramer and
Sutcliffe’ in their incorporation of a segmented display structure for raster devices into
the GINO-F package. Clearly this method will work, and is quite fast (obviously
depending on the complexity of the segment). However, the initial delete operation
will result in intersecting pixels of overlapping segments being set to o f . When the
overall picture gets into too much of a mess, an Update function can be used to redraw
all the segments in the display list. Although this method may be suitable in some
applications, it is not a generally satisfactory solution, both from the point of view of
aesthetics and user interface design. Parts of a picture disappearing must be disconcerting to users of interactive systems. The situation is worse if the segment contains
a fill area primitive. Substantial parts of the image could vanish, requiring frequent
recourse to the Update function.
Another problem with the previous two methods is that the hit detection necessary
SEGMENTS O N BIT-MAPPED GRAPHICS DISPLAYS
969
for Pick Input is very expensive. Given an arbitrary point on the display, usually
chosen by an operator using an input device, the problem is to find which segment (if
any) is being pointed to. The segmented display list must be searched, usually in a
priority order, until a segment is found containing a geometric object which is close
to the point. Clearly, the search time involved for a large display list could be
prohibitive, although Bramer and Sutcliffe give some test data showing that acceptable
timings can be achieved.
A fourth and more sophisticated method was used by Warner and Keifhaber’ and
also described by Foley and Van Dam.” Part of the description of a segment is its
extent, which is the smallest bounding rectangle enclosing all of the segment primitives.
Now when a segment S is transformed the following operations are carried out:
(a) Clear the pixels in the extent of S. This should be a fast operation, since it can
be done using rasterop.
(b) Redraw all segments which have extents which overlap the extent of S (and
using the extent of S as a clipping region).
(c) Redraw S in its new position according to the transformation applied. Clearly,
a new extent would have to be computed.
This method is superior to the ‘redraw everything’ and ‘dirty changes’ approaches. The
whole screen is not necessarily redrawn-only those segments with a possibility of
overlapping S are affected. Rectangular extents are appropriate because clearing a
rectangular area to white area is easy, as is clipping to such an area. Hit detection also
benefits, for segments with extents not including the hit point can quickly be rejected.
However, the method can lead to an entire screen redraw in the simplest of cases.
Suppose segment S includes a diagonal line across most of the screen. Even if no other
segment is close to S, the entire screen will be redrawn-for the extent of S must
include the diagonal line. Similarly, suppose S includes a boundary box enclosing the
drawing. Scaling of the boundary box to enlarge it or make it smaller would result in
the redrawing of all segments.
A final method is to write special-purpose firmware as part of the graphics device,
to maintain a segment data structure. This solution has been adopted, for example, in
the 6000 series graphics terminal produced by Sigmex U.K. Ltd., which embodies a
GKS workstation implemented in 68000 code. When a segment S is transformed the
entire display image is redrawn, with S transformed, into an off-screen buffer. On
completion, this buffer is switched to become the actual display. A similar scheme is
adopted by the STEP graphics terminal produced by the French company AMAIABayonne. (There are no doubt other machines which employ a similar approach.) This
method works because it is embodied in firmware-i.e.
because it is very fast. It
sidesteps the bit-maplsegment conflict, rather than resolves it-though it is clearly a
working solution. There are nevertheless drawbacks. Given a complex image containing
a large number of graphics primitives, redrawing everything can take a noticeable
amount of time even in 68000 code embodied in firmware. This is experienced by the
user as a delay in response to a segment manipulation command. However, this cannot
be held as a genuine criticism of this approach, for even on vector refresh devices,
screen flicker is the cost of displaying images with a large number of vectors. The real
drawback is that this solution is, of course, not portable. It must be reimplemented
from scratch for every new device. Moreover, it cannot help users with existing bitmapped equipment-there is little possibility of adding complicated firmware to interface an existing product correctly.
970
M. SLATER
3.
DESCRIPTION O F T H E METHOD
The objective of this investigation is to provide a method for dynamic changes on a
bit-mapped display, based on the segment concept. T h e method described results in
redrawing only those segments which have a high probability of intersecting the
changed segment S. If no segments intersect S then only S itself is redrawn. In other
words, the speed of the algorithm depends on the local complexity of the picture near
the affected segment. The same is true for hit detection: the speed of this operation
depends only on the complexity of the picture near the hit point. The algorithm is
simple, and the computations involved are almost entirely additions and bit shifts.
Special hardware or firmware is not required to achieve acceptable speed. T h e method
is described in abstract terms in this section, and implementation information is given
in sections 4 and 5. Run-time performance is discussed in section 6 and further work
is discussed in section 7.
The method is based on a division of the display space into a rectangular grid. If
there are ndivx divisions horizontally, and ndivy divisions vertically, then this generates
an ndivx X ndivy grid. For the sake of a naming convention, the grid cells are called
tiles, and numbered from 0 to ndivx- 1 horizontally and 0 to ndivy- 1 vertically. Tiles
will be denoted by t = (t.x,t.y), which is the (t.x,t.y)th tile. For example, the tile at
the bottom left-hand corner of the display is t = (O,O), in which case t . x = t.y = 0.
This is shown in Figure 3.
The basic graphics primitive is assumed to be one which draws a straight line
between two points. This primitive will be denoted by lineZ(pO,pl, seg) where p0 =
(pO.x,pO.y), pl = @l.x,pl.y)and seg is the name of the segment to which the line
(p0,pl) is to be appended.
The essence of the method involves finding the set of tiles intersected by any line,
which will be referred to here as tile conversion. This is similar to the usual process
of scan converting lines into pixels. However, tiles (unlike pixels) maintain information
identifying the segments that pass through them. Hence for every tile which a line
intersects, the corresponding segment-name is recorded in a data structure associated
with the tile. Suppose a segment S is to be made invisible. First, all lines in S are
redrawn using the 0 bit operator (i.e. the lines are cleared). An active segment list is
constructed which consists of the names of all segments which probably overlap S.
This list can be constructed easily, for it will consist of the union of all segment-names
stored at all the tiles intersected by S. All the segments in the active segment list are
then redrawn. If S is to be transformed, it is first made invisible as described above,
and then redrawn in its new position.
The method can be described formally in terms of two main data structures, and a
number of functions and procedures. The fundamental data structures of set, list and
array are assumed. g is used to denote the empty set and the empty list. E is used to
denote both set membership and list membership. The list cons function is denoted
by the infix operator:: Displayspace is used to denote the state of the screen.
Data structures
Let Tiling be an array, where for any tile t,, Tilinglt] is a set of segment-names. Let
Segment be an array where for any segment-name seg, Segmentlsegl is a list of lines.
97 1
SEGMENTS ON BIT-MAPPED GRAPHICS DISPLAYS
0
1
3
2
Figure 3. ndivr
=
4
ndivy
5
=
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20. TileslnLine = {(3,3),(4,3),(4,4),(5,4),(5,5)
,...,(15,11))
A point is described as x and y components (x, y) and a line is described by its two
endpoints. Let S be the set of possible segment-names, and I the set of indices to the
Tiling array.
Basic functions and procedures
function TileslnLine(1ine)
returns the set of tiles intersected by line.
function LineTran(line,T)
returns (Tp0,Tpl) where (p0,pl) = line and Tp0,Tpl are the endpoints transformed by
the transformation matrix T.
procedure DrawLine(line.op)
972
M . SLATER
results in line being displayed on Displayspace, using the op combination rule. The
only two values of op to be used here are 0 and 1, with 0 meaning off and 1 meaning
on.
procedure ClearDisplay
results in all pixels in Displayspace being set to off.
Derived basic functions and procedures
function TileslnSeg(seg)=
U
TileslnLine(I)
IGegment[segl
procedure DrawSeg(seg,op) = for all line E Segment[segl do DrawLine(line,op);
procedure SegTran(seg,T) = for all line E Segment[segl do line := LineTranUine, TI;
Derived high-level procedures
The algorithm can now be described in terms of the following procedure-definitions :
procedure lnitialise =
begin
ClearDisplay;
for all t E l do Tiling[t] : = 0;
for all sES do Segment[sl : = 0
end
procedure line2(line,seg) =
begin
DrawLine (line,l);
for all t€TileslnLine(line) do Tiling[t] : = Tiling[tlU{seg};
SegmentIseg] := line : : Segment[segl
end
procedure SetVisibilityOn(seg) =
begin
DrawSeg(seg.1);
for all t€TileslnSeg(seg) do Tiling[tl : = Tiling[tlU{seg}
end
procedure SetVisibilityOff(seg) =
begin
DrawSeg(seg,O);
for all tETileslnSeg(seg) do Tilingit1 : = Tilingkl - {seg};
U
Tilingrtl
let ActiveSegList =
tETileslnSeg(seg)
in
for all sEActiveSegList do DrawSegts,1)
end
SEGMENTS O N BIT-MAPPED GRAPHICS DISPLAYS
973
procedure TransformSeg(seg.T) =
begin
SetVisibilityOff(seg1;
SegTran(seg,T);
SetVisibilityOn(seg1
end
T H E T I L E S INTERSECTED BY A
LINE
4. T I L E CONVERSION-FINDING
Of crucial importance to the speed of the method is the execution time of the function
TileslnLine, which computes the set of tiles intersected by any line. The algorithm for
this computation is a simple generalization of Bresenham's line-drawing algorithm."
Consider a line joining points p 0 and p l . Let dx = p1.x - p0.x and dy = p l .y p0.y with dx > 0 and dy > 0. Let t O and t l be the tiles corresponding to p 0 and pl.
The algorithm to be constructed is defined recursively. Given an expression for the
tile discovered at the ith step in the execution, an expression is derived for the tile at
the (i+l)th step. Let ti = (ti.x,tj.y)be the tile at the ith step. It is then shown in the
Appendix that if W is the tile width, and H the tile height,
+ 1)
else if f t = 0 then (ti.x+l, ti.y + 1)
else iff;- < 0 then (ti.x + 1, ti.y)
ti+] = if fi> 0 then (tj.x,ti.y
where
fo = dx(p0.y MOD H ) - dy(p0.x MOD W) - Hdx
+ Wdy
and
fi = iff,-l > 0 thenfiP1 - Hdx
else if h-l = 0 then Wdy - Hdx
else if k.- < 0 then J - ] + Wdy
A similar result for the case dy < 0 can be derived easily, and the cases dx = 0 and
dy = 0 can be dealt with separately.
IMPLEMENTATION
The first implementation objective was to test the philosophy of the method. Does it
result in a system where segments can be manipulated in real time-in other words,
does the method support interactive work? The crucial determining factor is speed. As
usual, there is a time versus space trade-off. Therefore, the implementation concentrated on obtaining maximum speed at the cost of allowing the definition of only a
relatively small number of segments. Then a more general version was implemented
to allow a large number of segments.
It should be noted that the problem of hit detection is greatly reduced in the method
of this paper compared to earlier work. The speed of hit detection depends on the
974
M. SLATER
complexity, in terms of numbers of vectors and segments in the region near to the hit
point. This region is, of course, the tile in which the hit point is located. Since each
tile maintains the list of names of segments which pass through it, only this list need
be processed rather than all defined segments. The size of this list depends on the size
of tiles (i.e. on the number of divisions) used. In practice the Tiling matrix is likely to
be sparse, and each tile is likely to point to only a relatively few segment-names
compared to the number of segments defined. Obviously rogue cases exist where every
segment passes through every tile, but the occurrences of these are likely to be rare.
The first decision made in order to obtain maximum speed was to insist that the tile
width and height should each be powers of two, and in fact tiles were chosen to be
square. Therefore in the TileslnLine algorithm every operation becomes either a bit
shift or an addition. The only exception requiring two multiplications is in the initial
computation off.
The set operations specified in section 3 can be implemented easily and nacvely on
lists. Set union can be implemented as an insert function, where an element is inserted
into the list so that the list is maintained in ascending order-in order to avoid the
duplication of elements. Then Tiling is a two-dimensional array of pointers to lists of
integers representing the segment-names. The array size is ndivx X ndivy. Finally,
Segment can be represented as an array of pointers to lists of vectors, where a vector
consists of two points defining the end-points of a line. The Segment array is indexed
by the (integer) segment-names.
The second decision made to obtain maximum speed was to implement the set
operations using actual bit operations on integers. Here unsigned 32-bit integers were
used to represent a set of segment-names. The maximum number of segments allowed
was therefore 32. Set membership, union and difference can be represented by the bit
operations. The Tiling array in this scheme was an array of integers. This set of choices
seems to be especially suitable in applications requiring a small number of segments,
and where speed is of paramount importance.
This can be generalized in various ways. Each element of the Tiling array could be
a pointer to a linked list of pairs of integers, with the first integer in each pair
representing a set of 32 possible segment-names and the second integer representing the
lowest segment-number in the set. For example, if the only segments in the list were
65, 66, 67 and 68 then this would be represented as (30,64) since 30 as a bit map is
11110 and 64 is the largest power of 2 less than or equal to 65. As another example,
the list [(3,64);(248,992)] denotes the set of segment-names [64, 65, 995, 996, 997,
998, 9991.
Alternatively, the sets could be represented as arrays. For example, suppose the not
unreasonable maximum of 1024 segments was allowed. Then each element of Tiling
could be an array of 32 integers, representing a set of maximum size 1024. This would
have the advantage of constant time for set operations on the segment-names. However,
the cost is the large amount of memory required. For example, on the Whitechapel
MG1 workstation'2 on which the system was implemented, using a tile size of 32 X
32 bits causes the dimension of Tiling to be 32 X 25 since the display space resolution
is 1024 X 800. Therefore a total of lOOK bytes was required to store the Tiling array,
which is exactly equivalent to an extra screen full of memory. This seems excessive,
but it must be judged against the advantages that segmentation offers an application.
The demand for large amounts of memory in interactive applications on bit-mapped
displays is not unusual. For example, Cook's algorithm for overlapping rectangles
requires four screen-sized bit maps, although this includes double buffering.
SEGMENTS ON BIT-MAPPED GRAPHICS DISPLAYS
975
6. RUN-TIME PERFORMANCE
Two tests were carried out each on the implementation allowing 32 segments, so that
timing calculations were independent of the particular data structure used for the
elements of the Tiling array. The first test involved drawing 32 curves each in a different
segment. One of the segments contained a Sierpinski curve, and the other 31 segments
Hilbert curves.13 A Hilbert curve of order i is made up of 4’ - 1 short lines, and the
same is true for a Sierpinski curve of the same order. This was to simulate curvedrawing in CAD, where (for example) spline curves are generated by drawing sequences
of contiguous short lines. Figure 4 shows a random arrangement of such curves for
the case i = 4. Timings were taken for rotation and scaling, since these would be the
most computationally expensive operations. The test involved drawing the curves at
random positions on the display, then rotating the Sierpinski curve ten times, and
finally scaling 10 times. This whole operation was itself repeated 10 times. The tile
size was taken to be 32 X 32. When each curve was of order 2 (i.e. containing 15
lines) the overall mean rotation time was 0.08 s, and 0.04 s for scaling. For curves of
order 4 (containing 63 lines) the mean times for rotation and scaling were 0.23 and
0.20, respectively. For curves containing 255 lines the times were 1-12 and 1.16
seconds. Here scaling takes longer, because as the segment grows in size it overlaps
more segments, thus increasing the size of the active segment list. Finally, when each
curve contained 1023 lines, the mean rotation and scaling times were 21.5 and 19.0 s.
All timings were elapsed times, which included background activities such as disk syncs
which occurred every 30 s. These results are summarized in Table I.
Table I . Timings for rotation and scaling of Sierpinski curves
No. of lines in
curve
Mean rotation (s)
Mean scaling (s)
15
63
255
1023
0.08
0.23
1.12
21.50
0.04
0.20
1.16
19.00
A second test involved drawing 32 chess pieces, each made up of approximately 30
lines (including those used for shading). The user could pick any piece by pointing
using a mouse, and then shift, scale, rotate or delete the piece. The program proved
to be fast enough for genuine interactive manipulation of the pieces.
Experience generally suggests that segments of up to about 100 lines can be manipulated fast enough to allow the method to be used in interactive applications.
7.
FURTHER WORK
This paper describes an experimental system for the incorporation of segments on bitmapped displays. The method has proved to be a sound starting-point for further
investigation which is concentrating on the following issues :
(a) The structure of the Tiling array in real applications needs to be studied. It is
likely that the array will be sparse, and the array elements will tend to represent
976
M. SLATER
Figure 4.
sparse sets. If this is the case then a data structure can be employed which takes
account of these features, and which minimizes the amount of space needed. An
optimum solution needs to be found in the trade-off between time and space
requirements.
This paper has concentrated on segments consisting only of lines. Other geometric primitives need to be considered, although the extension of the method
to polygon fill and text primitives is straightforward. For polygon fill the same
algorithm used to scan convert the polygon (such as the Y-X algorithm described
by Newman and S p r ~ u l l ' ~could
)
be used to find the tiles covered by the filled
polygon. In other words when a filled polygon is to be made invisible, the Y-X
algorithm is employed relative to the tiling co-ordinate system, and as each
horizontal row of tiles is discovered it is cleared to white using rasterop. Text
can be represented by vectors, which would have the advantage of allowing full
scaling and rotation. This would be equivalent to the stroke precision text defined
by GKS. Characters stored as bit-maps could also be handled. T h e segment
would store the string of characters, the co-ordinate of the start point of the
string, and any information necessary to compute the smallest rectangle enclosing
the text, such as character height and spacing. This rectangle could then be used
to compute the tiles covered by the character string. Text stored in this way
(equivalent to GKS character precision) can be translated, but not rotated or
scaled.
SEGMENTS ON BIT-MAPPED GRAPHICS DISPLAYS
977
(c) If this method is to be used successfully in a general graphics package, and GKS
serves here as an example, then it has to be fitted correctly into the viewing
pipeline. In addition, the method for storing and accessing the segment-attributes
needs to be specified. This raises the question of how colour is to be incorporated,
thus allowing the method to be implemented for any raster display. This is part
of the more general problem of representing the primitive attributes in the
segment data structures.
(d) A major area for extension is the inclusion of segment priority. GKS allows a
priority to be associated with every segment. This is used both for determining
the order in which segments are redrawn in an update, and the order in which
the display list is scanned during hit detection for a Pick Input. If segments
include only lines, then priority ordering is not necessary in the case of redisplay.
However, once colour and area fills are included then priority becomes important.
This can be handled within the confines of the present method. Let
ASL(s)
U
=
Tiling[tl
tETileslnSeg(s)
ASL(s) is the set of all segments which are (probably) intersected by s (including
s itself), and which need to be redrawn if s is made visible. Now suppose that
a priority is associated with each segment, and that segments must be redrawn
in the correct priority order. Then the Closure of ASL(s) must be found, and all
segments in this set redrawn, where
Closure(s) =
u ASL(i) - {s}
iEASL(s)
This is in order to make s invisible. If this is part of a transformation operation,
then instead of next redrawing s in its new position, a similar closure set must
first be computed at this new position of s, and then all segments in the closure,
including s, redrawn in the priority order.
(e) Experience on the MG1 suggests that a tile size of 32 X 32 or 16 X 16 provides
suitable compromise values (determining the number of tiles as 32 X 25 or 64
X 50). The smaller the tile size, the larger the number of tiles and hence the
greater the execution time for the TileslnSeg function. However, if the tile size
is small then the number of elements in the active segment list will tend to be
smaller, leading to a shorter execution time for redrawing. The relationship
between these parameters needs further investigation.
(f) The method described in this paper is portable in that it can be implemented
on any workstation with a bit-mapped display and which supports the usual line
drawing and rasterop functions. Moreover the testing carried out so far indicates
that it works fast enough for interactive applications. However, there is a certain
amount of inefficiency involved, for every line is actually scan converted t w i c e
in order to discover the pixels it intersects and then again to find the tiles it
intersects. The first scan conversion is necessary for generating the line into the
screen bit-map. This is normally done in machine hardware or firmware. Second,
the tile conversion is carried out by the segment display algorithm. It is probably
worth investigation to see if these two operations can be combined.
978
M . SLATER
ACKNOWLEDGEMENTS
Thanks to Don Beal and Keith Clarke for helpful comments and suggestions, and to
Steve Cook and George Coulouris for commenting on an earlier draft. William Roberts
helped with much-needed laser printer advice.
APPENDIX
Consider the problem of computing the tiles intersected by the line joining points p 0
and p l . Let d x = p1.x - p0.x and dy = p1.y - p0.y with d x > 0 and dy > 0. Let
t O and t l be the tiles corresponding to p 0 and p l and ti = (ti.x,ti.y) be the tile at the
ith step. Y ( a )denotes the intersection of the line (p0,pl) with the vertical line x = a.
Then,
Y ( a )=po.y
+ dY
- (a - p O . x )
dx
Let a = W(ti.x + l ) , where W is the width of each tile. Then, if H is the height of
the tiles:
ti+ =
if Y ( a )> H(t,. y + 1) then (ti.x,ti.y + I )
else if Y(a)= H(ti.y + 1) then ( t,.x + I , ti.y
else if Y ( a )< H(t,.y 1) then (t,.x + 1, t,.y)
+
+ 2)
+
This can be seen from Figure 3. Let ei = Y ( a ) - H(ti.y
1). Then the resulting ti
depends on whether e, is positive, zero or negative. In the first case the y component
of t is incremented; in the second case both x and y are incremented and in the last
case only x is incremented. Now
ei = p0.y
dY (W(t;.x+ 1) - p 0 . x ) - H(ti.y + 1)
+ dx
-
Since dx > 0, multiply e, throughout by d x to obtainf; and the inequalities in the
algorithm are preserved.
f2 = dx X p0.y + dy(W(t,.x + 1) - ~ O . X ) - dx X H(t,.y + 1)
Consider now J - 1,
1 - 1
= dx
Xp0.y
+ dy(W(t,-i.x + 1) - ~ O . X ) - dx X H(t,-l.y + 1)
By subtraction,
f2 = J - 1 + Wdy(t,.x - t , - l . x ) - Hdx(t,.y - t,-l.y)
The value off2 gives a method for determining L , + ~ from t,. Therefore,f2-, determines
t, from t,-l. Hence,
iff,-l > 0 thenf, = f2--l - Hdx
if f2.-l = 0 then f2 = Wdy - Hdx
if f;.-l < 0 then f2. = fi-l + Wdy
SEGMENTS ON BIT-MAPPED GRAPHICS DISPLAYS
979
It remains to determine the initial value, fo:
fo = dx X p..y
+ dy(W(t0.x + 1) - P O X )
- Hdx(t0.y
+ 1)
which can be rewritten as
fo = dx(p0.y - Ht0.y)
+ dy(Wt0.x -POX + W) - Hdx
However, t0.x = p 0 . x DIV W and t0.y = p0.y DIV H . Therefore,
fo
= dx(p0.y
MOD H ) - dy(p0.x MOD W)
- Hdx
+ Wdy
A similar result for the case dy < 0 can be derived easily, and the cases d x = 0 and
dy = 0 can be dealt with separately.
The algorithm for generating the tiles intersecting the line (p0,pl) can therefore be
written as
function TileslnLine(p0,pl) =
begin
t0.x : = p0.x DIV W;
t0.y := p0.y DIV H;
t l .x : = p l .x DIV W;
t1.y := p1.y DIV ti;
TileSet : = {to};
t : = to
f := dx*(pO.y MOD H) - dy"(p0.x MOD W) - H*dx
+ W*dy;
do t.x # t l .x and t.y # t l .y +
if f > 0 + t.y : = t.y + 1;
f : = f - H*dx
0f
=
+
0 + t.x, t.y : = t.x
1, t.y
f : = W*dy - H*dx
+
1;
+ 1;
+ W*dy
0 f < 0 + t.x := t.x
f := f
fi;
TileSet := TileSet U {t}
od;
return (Tileset)
end
In the above function-definition {} are used to denote sets-{t} is the set with single
U is the set union operator. Note that the iteration ends with either
element t-and
t.x = t1.x or t.y = t1.y. This allows the simpler cases to be dealt with subsequently,
and also avoids the complication of testing for the situation where the end-point of a
line falls exactly on the vertical boundary of a tile.
REFERENCES
1. GINO-F User Manual, CAD Centre, Cambridge, U . K . , 1979.
2. 'Core graphics system: status report of the Graphics Standard Committee', Computer Graphics, 13,
August (1979).
980
M . SLATER
3 . GKS Infomation Processing Systems, Computer Graphics, Graphical Kernel System (GKS) Functional
Description, international Standard IS0 7942, 1985.
4. F. R. Hopgood, D. A. Duce, J. R. Gallop and D . C. Sutcliff, Intmduction to the Graphical Kernel
System (CKS), Academic Press, 1983.
5. A. Goldberg and D . Robson, Smalltalk-80: The Language and Its Implementation, Addison-Wesley,
1983.
6. R. Pike, ‘Graphics in overlapping bitmap layers’, ACM Transactions on Graphics, 2 , (2), 135-160
(1983).
7. S. Cook, ‘Playing cards on the Perq: an algorithm for overlapping rectangles’, Software-Practice
and Experience, 13, 1043-1053 (1983).
8. B. Bramer and D. C. Sutcliffe, ‘Application of Gino-F to use display file techniques on raster scan
displays’, in J. L. Encarnacao (ed.), Eurographics 81 Proceedings, 1981.
9. J. Warner and N. Keifhaber, ‘The DIGRAF implementation of the proposed G S P C standard’,
Eurographics 79, Bologna Italy, 1979.
10. J. D . Foley and A. Van Dam, Fundamentals of Interactive Computer Graphics, Addison-Wesley,
1982.
1 1 . J. E. Bresenham, ‘Algorithm for computer control of a digital plotter’, IBM Syst. J., 4, ( l ) , 25-30
(1965).
12. D. Pountain, ‘Realising a dream’, BY’l’E, 379-382 (1985).
13. Leslie M. Goldschlager, ‘Short algorithms for space-filling curves’, Software-Practice and Experience, 11, 99-100 (1981).
14. W. Newman and R. F. Sproull, Pn’nciples ofhteractive Computer Graphics, 2nd edn, McGraw-Hill,
1979.