Rendering
Parallelization of Bresenharn’s
Line and Circle Algorithms
William E. Wright
Southern Illinois University at Carbondale
0
ne approach to parallelization is to take several
procedures that require independent execution and
assign one or more processors to each procedure so
that they can be executed simultaneously, or at least
with a high degree of overlap. For example, in a graphics system we can assign one processor to do transformations, another clipping, and another line drawing.
Another approach to parallelization is to take a single procedure that requires execution for several different s e t s of arguments a n d assign multiple
processors to execute the procedure simultaneously
(over multiple sets of arguments). This is somewhat
analogous to a single instruction, multiple data model
of parallel computing.’ For example, we can assign
multiple processors to the line-drawing procedure in
60
a graphics system, with different processors assigned
different lines to draw.
I use a different approach in this article. I take a
basic procedure such as line or circle drawing and
implement it using parallel processors and a parallel
algorithm designed for that procedure. This is the
most elementary level of parallelization, and we can
use it with either or both of the other approaches.
Moreover, while the other two approaches are relatively straightforward, the algorithms for this approach require some development.
My algorithms assume that each pixel position has a
distinct memory address. If this is true, then synchronization should require very little time, because I designed the algorithms to avoid address contention, in
0272-17-16/90/0900-0060S0100 01990 IEEE
IEEE Computer Graphics &Applications
which two processors attempt to access the same
pixel position simultaneously. If the assumption is
not true, then I’ll have to modify the algorithms to
eliminate the possibility of contention or to provide
proper coordination. This article does not include
such modifications.
Robert Sproull presented a different parallel technique for line drawing., Pike discussed a different
technique for “starting a line in the middle,”3which
is one of the features of the line algorithm I present. I
also present the parallel line algorithm here for the
sake of completeness and to serve as an introduction
to the circle algorithm.
insert appropriate logic to always draw the line from
(xo,yo)to (xpyf).I limit my discussion to the algorithm
a n d its parallelization as stated here, b u t t h e
parallelization of the other version is very similar.
Basically, the algorithm moves the x coordinate step
by step from left to right along the line. At each step,
we choose the y coordinate to be the same as or one
larger than the previous y coordinate. Which choice to
make for the y coordinate depends on whether the
current value of the integer variable p is negative or
nonnegative. We also update the value of p at each
step, again depending on whether its current value is
negative or nonnegative.
Dividing the work and getting started
The line algorithm
Let’s suppose that we need to determine the raster
representation of the straight line between two given
endpoints (xo,yo)and (xpyJ where xo,yo,xp andyfare
integer coordinates. Let dx = xf - xo and dy = yf - yo.
Then the slope m of the line is given by m = dy/dx (if
dx # 0). I will suppose without loss of generality that
d x 2 d y 2 0 , so that 0 5 m I
1.It is convenient to design
an algorithm for this case and then apply straightforward extensions or modifications for other cases ( m>
1or m < 0).
Let n = xf-xo and let xi = xo + ifor i = 1, , n.The
problem for the raster algorithm is to determine integer values y,, y,,
, y, = yfsuch that, for 1 I i I
n,the
point (xi,yi)is closer to (or as close as) the true line
than any other point with x coordinate xi and an integer y coordinate.
Clearly, yi can be chosen as RoundCf(xi))where y =
f(x) is the equation of the line. (For precision, let’s
assume that Round(a + 0.5) = a + 1,for any nonnegative integer a.) If dx # 0 , then an equation for the line
is y = mx + b, where b = yo- m(xo).Hence, we get yi =
Round(m(xi)+ b) =yo+ Round(mi).
e . .
The parallel version given here for Bresenham’s line
algorithm divides the interval from xo to xf into P
approximately equal subintervals, where P is the
number of processors available. In effect, each processor determines the raster representation for the line
segment for the x coordinates lying in the subinterval
assigned to it. Pixel addresses determined by different
processors do not overlap.
The main trick for each processor (except the first) is
to get started, that is, to determine the proper initial
values of y and p . Each processor will in effect “jump
into the middle” of the sequence of calculations normally performed by the sequential algorithm in determining y and p.
Let’s start by defining w as the ceiling of (dxlP).
Then w is the width of the subinterval assigned to
processor k, except that the last processor (and possibly other processors as well) may have a smaller (or
even 0 ) width to accommodate truncation errors. Letting Div denote integer division, we get
w = Ceiling(&+) = (dx + ( P - 1))DivP
(1)
Now assume that the processor number is k, where
p ( k ) ,respectively,
Bresenham designed an efficient sequential line aldenote
the
proper
initial
values
for
variables x, y, and
gorithm? described in a number of sources (such as
p
for processor k. To be precise, yo + ylk) is the y
the work by Foley and Van Dam5).I refer primarily to
coordinate of the pixel whosexcoordinate is xo+ x(k),
the algorithm as Hearn and Baker presented it.6
and p(k)is the value that p would have in the sequenBresenham’s line algorithm determines the values for
tial
algorithm exactly when the pixel (xo+ x(k),yo +
y,, y,, - .. , y, without using floating-point arithmetic.
y(k)) is set. I will define x(k) by
x,,The algorithm does not initially require that x,2
,
but it swaps the endpoints if not. It does assume that
(2)
x(k) =
after the swapping (if needed), yf2yo,so that in either
case the slope of the line lies between 0 and 1. This
swapping will cause problems with the implementa- We can now see from the sequential algorithm that
tion of line style attributes. Hence, in some systems it ylk) = Round(m .x(k))andp(k) = 2dy- dx + 2 dy(x(k))
might be preferable to eliminate the swapping and - 2dx(y(k)).
The sequential line algorithm
September 1990
0 5k I
( P - 1). Let x(k), y(k),and
61
We can eliminate floating-point computations and
otherwise reduce the computations required by using
the following derivations:
The speedup SIP, dx) = t,(dx)/tp(P, dx) of the parallel algorithm approaches the perfect value ofPas dx
gets larger.
Of course the values of A, B, and C depend on the
implementation,
but I made a rough analysis by simut(k)= dy * x(k)
(3)
y(k) = Round(m .x(k))
lating an implementation in Turbo Pascal on an Intel
8088-based personal computer. I don’t intend the re= Truncate(m . x(k) + 0.5)
sults to demonstrate the precise performance of the
(
2
.
dy
x(k)
+
dx)
= Truncate
(2 * dx)
two algorithms, but rather to show their relative performance in general terms. Other implementations
= ( 2 . t(k)+ dx)Div(2. dx)
(41
will probably yield slight differences, but the basic
p(k)=Z.dy-dx+2.t(k)-Z.dx.y(k)
(5)
pattern will be the same.
The results are as follows, using an imaginary time
We thus have the basis for an algorithm requiring
unit in which the time through one iteration of the
three integer multiplications and one or two integer
divisions. (I exclude multiplication or division by a While loop is 1:
power of two, which can be implemented as a left or
c=1
right shift.) The multiplications are k . w in Equation
A
= 3.74
2 , dy . x(k) in Equation 3, and dx .y(k)in Equation 5.
B
= 6.54 = 1 . 7 5 ~ 4
= A + 2.80
Integer division is required in Equation 4 and also in
Equation 1if P is not a power of two.
The setup cost for the sequential algorithm is the
equivalent
(in time) of about 4 loop iterations, and the
The parallel line algorithm
setup for the parallel algorithm requires the equivaFigure 1shows the parallel line algorithm in Pascal.
In this case, the formal parameter k is the processor lent of about 3 loop iterations more.
The timing formulas now become:
number and P-Minus-1 is a constant equal to P - 1.
Basically, the unnumbered lines in the algorithm are
the same as in the sequential algorithm. Line 1 declares new variables, and Lines 2 through 13 constitute new executable statements. (Actually, Lines 4
and 1 3 replace statements in the sequential algorithm.) Note that all of the additional computation
falls outside the While loop.
Analysis of the line algorithm
The time for executing the sequential algorithm on a
particular line segment is given by t,(dx, dy) = A + C,(1
- m)dx + C, . m . dx. A is the time component corresponding to the setup statements preceding the While
loop, C, is the time required for one iteration of the
While loop when y is not incremented, and C, is the
time for one iteration when y i s incremented. Since C,
and C, are relatively close, it is reasonable to use the
simpler approximation given by t,(dx) = A + C . dx.
The time for executing the parallel algorithm on a
particular line segment is given similarly by t,(P,dx) =
B + C(Ceiling(dxlP))=B+C(dx/P).Pis thenumber of
processors, B is the time component corresponding to
the setup statements preceding the While loop, and C
is the same as for the sequential algorithm. Clearly,
then, the parallel algorithm has a larger constant setup
cost, and the loop time, which is proportional to dx, is
reduced by a factor of P.
62
t,( dx) = 3.74 + dx
t J P , dx) = 6.54 + dX/p
For example, when we set dx to 100, we get tJ100) =
104, tp(4,100) = 32, and S(4,lOO) = 3.3.
Using the values above, we can show that the parallel algorithm will be faster than the sequential algorithm when dx 2 2.8P/(P - 1).Thus, if P = 2 , then the
parallel algorithm is faster for all dx 2 6. If P = 3, then
the parallel algorithm is faster for all d x 2 5. If P = 4, 5,
. . , 14, then the parallel algorithm is faster for all d x >
4, and if P 2 15, the parallel algorithm is faster for all
d x > 3.
The sequential circle algorithm
Using an approach similar to the one just presented
for straight lines, I developed a parallel algorithm for
drawing circles. Bresenham designed an efficient sequential circle a l g ~ r i t h r n , ~
and
. ~ McIlroy,’ Suenaga,
Kamae, and K o b a y a ~ h iand
, ~ others described different circle algorithms. Nevertheless, I refer primarily
to Bresenham’s work.
The basic approach of the algorithm is to move the x
coordinate step by step from its value at the top of the
circle (at 90 degrees or due north) to its value on the
circle at 45 degrees or northeast. In other words, x
IEEE Computer Graphics &Applications
Procedure par-bres-line(k, x0,y0, xf, yf : Integer);
t2 := x. constl;
(7)
Var
y := ( t 2 + dx) Div t l ;
(8)
dx, dy, x, y, x-end, p , constl, const2 : Integer;
p := constl - dx + t 2 - t l . y;
19)
w, xs,ys, t l , t2 : Integer;
const2 := constl - t l ;
(1)
Begin
x := x + xs;
(101
dx := AbS(x0 - xf);dy := Abs(y0-yf);
x-end := x-end + xs;
(11)
(Do not compute p yet)
y:=y+ys;
(12)
constl := 2 . dy;
If k = 0 Then set_pixel(xs,ys);
(13)
(Do not compute const2 yet)
While x < x-end Do
If xO>xf Then
Begin
Begin xs := xf; ys := yfEnd
x := x + 1;
Else Begin xs := x0; ys := y0 End;
If p < 0 Then p := p + constl
Else Begin y := y + 1;p := p + const2 End;
w := (dx + P-Minus-1) Div P;
(2)
set-pixel(x,y);
x : = k -W ;
(3)
x-end := x + w;
(4) End
If x-end > dx Then x-end := dx;
(5) End
t l := dx + dx;
(6)
Figure 1. The line algorithm in parallel.
ranges from 0 to xmax= Floor(radius cosine(45 degrees)).
They coordinate starts with its value at the top of the
circle (y = radius), and at each step the algorithm
chooses the new y coordinate to be either the same or
one less than the previous y coordinate. The algorithm chooses the y coordinate based on whether the
current value of the integer variable p is negative or
nonnegative. The algorithm also updates the value of
p at each step, again by an amount depending on
whether its current value is negative or nonnegative.
In this manner the algorithm determines the best
raster representation of the true semicircle in the
angle from 90 to 45 degrees. Symmetry determines the
points for the remaining seven eighths of a circle.
tion will require the computation of a square root or
some other relatively expensive function. This follows from the equation of a circle with center at the
origin and a radius of r, which is 2 + y” = %, or y = k((%
- x ~ ) O . ~ I. can also write y = r sin(arccos(x1r)).
In any case, the dependency of x and y on r make a
simpler calculation impossible, hence this approach
requires a start-up overhead that is probably unsatisfactory.
An alternative might be to use a table of stored values of y as a function of r and the processor number.
We might incorporate the use of interpolation to reduce the size of the table. The number of values required would be ( P - 1). x,,, without interpolation
(since no values would be needed for Processor 0).
This is a classic trade-off of space for time-its impleDividing the work
mentation is straightforward and requires no further
There are two obvious approaches for dividing this discussion here.
work among P processors. One approach involves diThe second approach for dividing the work among
viding the range of the x coordinate, from 0 to xmax, processors involves dividing the arc of the circle, from
into Pfairly equal segments, then assigning a different 90 to 45 degrees, into P nearly equal subarcs and asprocessor to each segment to perform the appropriate signing a different processor to do the computations
computations.
for each subarc. For example, if P = 4, then each proThis approach requires each processor (other than cessor would be responsible for a subarc of approxithe first one) to determine its initial y coordinate after mately 45 degrees14 = 11.25 degrees. We can employ
determining its initial x coordinate. This determina- some tricks to efficiently determine the initial values
I
September 1990
63
for the x and y coordinates and for p , therefore this
approach leads to an efficient parallel algorithm for
circle drawing.
As mentioned previously, division by a power of 2 is
implemented as a right shift, hence the computation
of Equations 11 and 1 2 requires an integer multiply
and a shift for each. In effect, we approximate the
sines and cosines to an accuracy o f t binary bits.
Initial values for variables x,y , and p
Some finite arithmetic errors are inevitable in approximating A and B and in dividing by 2‘. An error in
Let k denote the processor number, where 0 I
k I computing x(k) is of no direct concern, since the start
P - 1. Let x(k) be the initial value of variable x for of each subarc is somewhat arbitrary. However, it is
processor k , let Y(k)be the initial value of variable y imperative that Y(k)be exactly the same as they coorfor processor k , and let y(k) be an initial approxima- dinate that we determined for the x coordinate x(k)
tion for Y(k). (I will often omit the reference to k i n x, (using the sequential circle algorithm). In other
Y,y, and other values where the dependency on k is words, we must have
understood.) Let G(k) = (k/P)45degrees.
Temporarily, we use the following formulas:
Y(k)= Round(g x(k))
(13)
-
~ ( k=) Round(r cOs(90 - G)) = Round(r. sin(G))
y(k)= Round(r. cos(G))
- 2))0.5
is the equation of the circle.
where g(x) = ((3
Because of errors in computingy(orx], it is possible
that Equation 13 will not be satisfied for Y = y. The
Note that the
can use stored
Of the
algorithm therefore tests three possible values for Y,
sine and cosine functions for fixed P and for k = 0 , 1 , namely yl = y, y, = + 1, and y, = - 1. The value
, P - 1.Therefore, the sine and cosine calculations chosen will be the one that gives a point closest to the
are not performed within the algorithm itself. Accord- true circle, that is, the one that minimizes the formula
ingly, let
9- 2 - y,: i = I , 2 , 3 . Let
e
A”(k) = sin(G)
B”(k)= COS(G)
d,
Then
x = Round(r . A”)
(8)
-
1)Z
Then
d, = d, - 2y- 1
d, = d, + 2y- 1
and
y = Round(r B”)
= 3- 2- ( y -
(9)
We can now use Equations 14,15,and 16 to determine
the proper value for Y.
After determining the correct starting values x(k)
and Y(k),we need to determine the correct starting
value p(k). As Hearn and Baker‘ and Bresenham7
showed, p(k)= 2 (x+1)’+ Y2+ (Y-1)’- 2r2.If Y =y ,
t = 1+ Ceiling(log,(r,,
+ 1))
(10) thenwegetp(k)= - 2 d l + 4 x - 2 y + 3.If Y = y + 1,then
we get p(k)= -2d, + 4 x + 2y+ 3. If Y =y - 1,then we
Then let A’(k) = 2‘ sin(G), B’(k) = 2‘ cos(G), A(k) = get p ( k ) = - 2 4 + 4x - 6 y + 7. In any case, the compuRound(A’), and B(k) = Round(B’). Now replace Equa- tation of p ( k ] requires no additional multiplications
or divisions beyond that used to compute x(k) and
tions 8 and 9 with
Y(k).
It is important, of course, to avoid the floating-point
arithmetic implicit within Equations 8 and 9. Accordingly, let r,, denote the maximum possible value of
the radius r (that is, 1,023 or 32,767),and let
(11) Proof of closeness
tiB)
y = Round 7
64
Now we need to prove that the correct value of Y(k)
is one of the values y, y + 1,or y- 1. To prove this we
(12) use one lemma. First, let’s introduce the following
notation:
IEEE Computer Graphics &Applications
Procedure par-bres-circle
Begin y := y - 1;
(k,x-center, y-center, radius : Integer);
p : = p - y 2 - y 2 - yZ + 7 End
Const
Else p := p - y2 + 3;
A, B, and Ware multiplied by 2 in order to
x-stop(@ := x;
facilitate Rounding in Lines 2 and 3.
Synchronize;
A = Fill in the correct integer constant using the
xstop := x-stop& + 1)
formula A = 2 Round(Zfsin((k/ P ) 45 ”))
B = Fill in the correct integer constant using the
While x < xstop Do
formula B = 2 Round(2‘cos ( ( k/ P ) 45 ”))
Begin
W = Fill in the correct integer constant using the
plot-circle-points ;
formula W = ~ ( 2 ’ )
If p < 0 Then p := p + 4 . x + 6
Var
Else Begin p := p + 4 (x- y) + 10;
p , x, y : Integer;
y : = y - 1End;
x:=x+l
d l , d 2 , d3, abs-dl, y2, xstop : Integer;
(1)
Begin
End;
x := (radius. A + 1)DivW,
(2)
y := (radius B + 1)DivW,
End;
(3)
y2 : = y + y ;
(4)
d l := (radius + x) (radius - x) - y y;
(5)
dz := d l - y2 - 1;
The procedure for Processor P - 1 is the same as
(6)
d3 := d l + y2 - 1;
(7) above, except for the following minor changes:
Abs-dI := Abs(d l ) ;
( 8 ) Line 19 is not needed.
p := 4. X - 2 d l ;
19) Line 20 should be changed to:
If Abs( d2) < Abs-dl Then
While x < y Do
(10)
(20)
Begin y := y + 1;
(11) Line 2 1 should become as follows:
If x = y Then plot-circle-points
(21)
p:=p+y2+3End
(12)
Else If Abs(d3) < Abs-dl Then
(13) The variable “xstop” is not needed in Line 1.
-
-
-
Figure 2. The circle algorithm in parallel. This example is the procedure for 0 5 k I P - 2.
x ’ = r sin(G)
y ’ = r . cos(G)
Theorem 1. Y(k)is equal to one of the values d k ) ,
yIk) + 1,or y(k) - 1.
Proof. From Equation 13 we need to show that
Round(g(x))
= y, Round(g(x)) = y + 1,or Round(g(x))=
dfl = y - y “
y
1.
This
is equivalent to showing that y - 1 I
dX 2 = x “ - x ‘
d =y”-y’
YZ
Round(g(x)) I y + l,thatis,y-1.5<g(x)<y+1.5.We
therefore need only show that I g(x)- yl < 1.5.
Lemmal. Ix-x’l <0.75and ly-y’l <0.75.
Recall that g(z)= (3- 2)0,5.
Therefore, the derivative
Proof. It follows immediately from the above nota- dg(z)/dz= -z (2In the interval 0 5 z5 rcos(45
2 z.Therefore, I dg(z)/dzI
tion that x ’ = rA ‘/2’ and y ’ = rB’/2‘. By definition of degrees),we have (2the Round function, I d,, I = I Round(rA/2‘)- rA/2’ I 5 I 1on this interval. Therefore, I g(x)- g(x ’) I 5 I x - x
0.5 and IA - A‘I = IRound(A’) - A’I I 0.5. From ’ I < 0.75 by Lemma 1. Now g(x’) = g(r sin(G)) = r
Equation 10 we get t - 12 logz(rm, + 1).Therefore, 2f-1 cos(G) = y’. Therefore, Ig(x) - y’l < 0.75.Using the
2 r,, +1,therefore 2‘-’ > r,
and therefore rm,/2 ‘< 0.5. second part of Lemma 1, we finally get I g(x) - yl 5
Now we can get I d,, I = I rA/2‘- rA’/2‘ I = r/2’ I A - Ig(x)-y’l+ ly’-yl <0.75 +0.75 =1.5,andtheproof
A’ I I rmm/Zt I A - A’ I< 0.5 -0.5 = 0.25. We therefore is complete at last.
get Ix-X’I 5 Ix-x”I + Ix”-x’l = ldxll + Idx21<
The parallel circle algorithm
0.5 + 0.25 = 0.75.
I can now present the parallel circle algorithm in
By a symmetrical argument for the y coordinate, we
Pascal, as in Figure 2. The algorithm makes use of the
get I y - y’I< 0.75.
following global array in shared memory:
We are now ready to prove the following theorem:
dx,= x - x ”
September 1990
65
x-stop: Array(0.J-Minus-1) of Integer
Letting B denote the setup time for the statements
preceding the While loop, the processing time for the
parallel algorithm becomes t,(P, r) = B + W(0) = B +
C . r (sin(45 degreeslP) + (v - 1) (1 - cos(45 degreeslP))). Letting A denote the setup time for the
statements preceding the While loop in the sequential
algorithm, the time for the sequential algorithm is
given by t,(r) = A + C . r (sin(45 degrees) + (v-l)(l cos(45 degrees))) = A + C . r (0.414 + 0.293~).
As r gets large, the effect of A and B becomes insignificant. Approximating v as 1.0, w e get L(P) =
lim,,S(P,
r) = sin(45 degrees)/sin(45 degreeslP). For
example, L(4) is approximately 3.62, and L(16) is approximately 14.4. Letting R(P) = L(P)/P denote the
ratio of L(P) to the maximum possible speedup of P ,
we have
The starting x coordinates for processors 0, 1,... ,
P - 1 are stored in this array. The stopping x coordinate for processor k, 0 5 k 5 P - 2, is taken to be the
starting x coordinate for processor k + 1. There is a
slightly different procedure for processor P - 1. Note
that this technique, including appropriate synchronization, can be avoided if each processor computes
both x-start and x-stop, but that would reduce concurrency.
I assume that the Synchronize procedure invoked
below delays each of the parallel processors until all
of them have executed the Synchronize. The procedure plot-circle-points, given in Step 7 , uses symmetry to plot eight points for each (x,y) pair, except that
if x = 0 or x = y, then it should plot only four points.
Line 1 in the parallel algorithm declares new variables, and Lines 2 through 20 constitute new executable statements. (Actually, Lines 2 , 3, 9, and 2 0
replace statements in the sequential algorithm.) Note
It can be shown that R(P) is a decreasing function in
that the additional computation requires no divides P, therefore R(1) > R(2) > . . . > 90.03 percent.
and only four multiplies (in Lines 2,3, and 5), and that
As for the line algorithm, I made a rough analysis
it lies entirely outside the While loop. I assume that using a simulated implementation of the circle algomultiplication or division by a power of two is imple- rithm in Pascal on an Intel 8088-based personal commented as a shift.
puter. The results are as follows, using an imaginary
time unit in which the time for one iteration of the
Analysis of the circle algorithm
While loop is 1:C = 1,A = 0.26, B = 0.86, v = 1.03.
The analysis of the parallel circle algorithm is not as
Using these parameters, the timing formulas beclean as for the parallel line algorithm for two primary come
reasons. First, the algorithm does not evenly distribute the iterations of the While loop among the P prot,(r) = 0.26 + 0.7161cessors. Second, the rate of execution of each of the
tp(P,r)= 0.86 + r(sin(45Y~)
two paths within the While loop is not a constant over
+ 0.0 3(1-COS (45"4))
the range of the loop control variable.
The lower numbered processors, whose subarcs
For example, t,(100) = 72, tp(4,100) = 20, and S ( 4 , l O O )
start closer to the top of the circle, will have more
= 3.5.
iterations of the While loop because they cover a
Using the parameters above, we can see that the
greater horizontal distance. On the other hand, lower
parallel algorithm with P 2 2 will be faster than the
numbered processors will also more often take the
sequential algorithm for all r > 2.
shorter path through the While loop (that is, the path
for p < 0 ) because they will decrease y less often.
In general, the time W(k) for the execution of the
While loop by processor k is given by W(k)= C . I(k)
Concluding remarks
(U&) + (1-u(k))v),where Cis the time for execution of
I developed and analyzed two efficient parallel algoone iteration when the shorter path is taken, I(k)is the
number of iterations, u(k) is the haction of iterations rithms for drawing graphics primitives on a raster
that take the shorter path, and v is the ratio of longer scan display device. One algorithm generates lines
path time to shorter path time (103 percent in my and the other generates circles. The line algorithm
implementation). For almost all practical cases, W(k) approaches a perfect speedup of P as the line length
is maximized at k = 0 , hence I shall take the processing approaches infinity, and the circle algorithm aptime for the parallel algorithm as a whole to be the proaches a speedup greater than 0.W as the circle
radius approaches infinity.
time for processor 0.
66
IEEE Computer Graphics & Applications
Both algorithms have a relatively small setup overhead. For the line algorithm the setup includes only
three integer multiplies and one or two integer divides and is equivalent to about seven loop iterations.
For the circle algorithm the setup includes only four
integer multiplies and no divides and is equivalent to
about one loop iteration.
We can extend this approach for parallelizing elementary algorithms to other graphics processes.
Drawing ellipses and filling polygons look like two
good candidates for future parallel work.
rn
3D at HP
Hewlett-Packard Laboratories currently has
two challenging positions in 3D computer
graphics research and development.
All applicants should have UNIX* operating
system, X-Window application, graphics
algorithms and extensive programming
coursework or experience.
Hardware Design
Engineer
References
1. M.J. Quinn, Designing Efficient Algorithms for Parallel Computers, McGraw-Hill, Hightstown, N.J., 1987.
2. R.F. Sproull, “Using Program Transformations To Derive Line-
drawing Algorithms,” ACMTrans. Graphics, Vol. 1 , No. 4, Oct.
1982, pp. 259-273.
3. R. Pike, “Graphics in Overlapping Bitmap Layers,”ACM Trans.
Graphics, Vol. 2, No. 2, Apr. 1983, pp. 135-160.
4. J.E. Bresenham, “Algorithm for Computer Control of a Digital
Plotter,” IBMSystemsJ.,Vol. 4, No. 1,Jan. 1965, pp. 25-30.
5. J.D. Foley and A. Van Dam, Fundamentals oflnteractive Computer Graphics, Addison-Wesley, Reading, Mass., 1982, pp.
433-436 and 442-445.
6. D. Hearn and M.P. Baker, Computer Graphics, Prentice-Hall,
Englewood Cliffs, N.J., 1986, pp. 58-61 and 67-69.
7. J.E. Bresenham, “A Linear Algorithm for Incremental Digital
Display of Circular Arcs,” Comm. ACM, Vol. 20, No. 2, Feb.
1977, pp. 100-106.
8. M.D. McIlroy, “Best Approximate Circles on Integer Grids,”
ACM Trans. Gmphics, Vol. 2 , No. 4, Oct. 1983, pp. 237-263.
9. Y. Suenaga, T. Kamae, and T. Kobayashi, “A High-speed Algorithm for the Generation of Straight Lines and Circular Arcs,”
IEEE Trans. Computers, Vol. C-28, No. 10, Oct. 1979, pp. 728736.
William Wright is a professor of computer
science at Southern Illinois University, Carbondale. His primary area of research is file
organization, especially tree-structured files.
He has also done research in data structures
and in cluster analysis. He is a member of ACM
and the IEEE Computer Society.
Wright received a masters degree in mathematics from the University of Illinois in 1968
and a doctorate in applied mathematics and
computer science from Washington University in 1972.
Wright can be reached at Southern Illinois University, Computer
Science Department, Carbondale, IL 62901-4511.
September 1990
Your expertise will be used to architect,
characterize, and design 3D raster graphics
hardware in conjunction with high performance computer workstation design.
Experience in high speed digital design,
VLSI circuit design, RISC processor based
computer design, and parallel processing
hardware design is required. Experience in
the application of graphics algorithm
techniques is desired. A PhD or MS with job
related experience in EE, CS, or equivalent
with expertise in hardware design for 3D
graphics workstations is required.
3D Graphics Software
Engineer
You will be responsible for designing 3D
graphics rendering algorithms for a high
performance workstation architecture.
Experience in polygon rendering and
advanced rendering algorithms is required.
Familiarity with object oriented programming and window system programming is
also preferred. We require a PhD or MS, or
equivalent, with job related experience in
CS or a related area with expertise in 3D
graphics rendering algorithms.
Please send your resume to:
Hewlett-Packard Laboratories, 1501 Page
Mill Rd., Bldg. lU,Dept. 6010, Palo Alto,
CA 94304. Hewlett-Packard Company is an
Equal Opportunity/Mirmative Action
Employer.
*UNIX is a registered trademark of AT&T in the U.S.A.
and other countries.
There is a better way
Pa
HEW LETT
PACKARD