LINE-DRAWING ALGORITHMS:

These equations form the basis for determining deflection

voltages in analog devices. For lines with slope
magnitudes |m| < 1, x can be set proportional to a
small horizontal deflection voltage and the
corresponding vertical deflection is then set proportional
to y as calculated from Eq. 3-4.
For lines whose slopes have magnitudes |m| > 1, y can be
set proportional to a small vertical deflection voltage
with the corresponding horizontal deflection voltage set
proportional to x, calculated from Eq. 3-5.
For lines with m = 1, x = y and the horizontal and vertical
deflections voltages are equal. In each case, a smooth
line with slope m is generated between the specified
endpoints.
On raster systems, lines are
plotted with pixels, and step
sizes in the horizontal and
vertical directions are
constrained by pixel
separations. That is, we must
"sample" a line at discrete
positions and determine the
nearest pixel to the line at
each sampled position. This
scan conversion process for
straight lines is illustrated in
Fig. 3-4, for a near horizontal
line with discrete sample
positions along the x axis.
 DDA Algorithm:

The digital differential analyzer (DDA) is a scan-conversion

line algorithm based on figure 3-4 calculating either y or
x, using Eq. 3-4 or Eq. 3-5. We sample the line at unit
intervals in one coordinate and determine corresponding
integer values nearest the line path for the other
coordinate.
Consider first a line with positive slope, as shown in Fig. 3-3.
If the slope is less than or equal to 1, we sample at unit x
intervals (x = 1) and compute each successive y value as
yk+1 = yk + m
Subscript k takes integer values starting from 1, for the first
point, and increases by 1 until the final endpoint is
reached. Since m can be any real number between 0 and 1,
the calculated y values must be rounded to the nearest
integer.
DDA Algorithm:
 DDA Algorithm:

Equations 3-6 through 3-9 can also be used to calculate

pixel positions along a line with negative slope. If the
absolute value of the slope is less than 1 and the start
endpoint is at the left, we set x = 1 and calculate y
values with Eq. 3-6.
When the start endpoint is at the right (for the same slope),
we set x = -1 and obtain y positions from Eq. 3-8.
Similarly, when the absolute value of a negative slope is
greater than 1, we use y = -1 and Eq. 3-9 or we use
y = 1 and Eq. 3-7.
 DDA Algorithm:
This algorithm is summarized in the following procedure, which
accepts as input the two endpoint pixel positions. Horizontal
and vertical differences between the endpoint positions are
assigned to parameters dx and dy. The difference with the
greater magnitude determines the value of parameter steps.
Starting with pixel position (xa, ya), we determine the offset
needed at each step to generate the next pixel position along
the line path.
We loop through this process steps times. If the magnitude of dx
is greater than the magnitude of dy and x a is less than xb, the
values of the increments in the x and y directions are 1 and m,
respectively. If the greater change is in the x direction, but x a
is greater than xb, then the decrements -1 and -m are used to
generate each new point on the line.
Otherwise, we use a unit increment (or decrement) in the y
direction and an x increment (or decrement) of 1/m .
DDA Algorithm:
 DDA Algorithm:
The DDA algorithm is a faster method for calculating pixel
positions than the direct use of Eq. 3-1. It eliminates the
multiplication in Eq. 3-1 by making use of raster
characteristics, so that appropriate increments are applied
in the x or y direction to step to pixel positions along the
line path. The accumulation of roundoff error in successive
additions of the floating-point increment, however, can
cause the calculated pixel positions to drift away from the
true line path for long line segments.
Furthermore, the rounding operations and floating-point
arithmetic in procedure lineDDA are still time-consuming.
We can improve the performance of the DDA algorithm by
separating the increments m and 1/m into integer and
fractional parts so that all calculations are reduced to
integer operations.
 Bresenham's Line Algorithm :
An accurate and efficient raster line-generating algorithm,
developed by Bresenham, scan converts lines using only
incremental integer calculations that can be adapted to
display circles and other curves.

Figures 3-5 and 3-6 illustrate sections of a display screen

where straight line segments are to be drawn. The vertical
axes show scan-line positions, and the horizontal axes
identify pixel columns. Sampling at unit x intervals in these
examples, we need to decide which of two possible pixel
positions is closer to the line path at each sample step.
 Bresenham's Line Algorithm :
Starting from the left endpoint shown
in Fig. 3-5, we need to determine at
the next sample position whether to
plot the pixel at position (11, 11) or the
one at (11, 12). Similarly, Fig. 3-6
shows a negative slope-line path
starting from the left endpoint at pixel
position (50, 50). In this one, do we
select the next pixel position as
(51,50) or as (51,49)? These questions
are answered with Bresenham's line
algorithm by testing the sign of an
integer parameter, whose value is
proportional to the difference
between the separations of the two
pixel positions from the actual line
path.
 Bresenham's Line Algorithm :
To illustrate Bresenham’s approach, we
first consider the scan-conversion
process for lines with positive slope less
than 1. Pixel positions along a line path
are then determined by sampling at unit
x intervals. Starting from the left
endpoint (x0, y0) of a given line, we step
to each successive column (x position)
and plot the pixel whose scan-line
y value is closest to the line path. Figure
3-7 demonstrates the k th step in this
process. Assuming we have determined
that the pixel at (xk, yk) is to be displayed,
we next need to decide which pixel to
plot in column xk+1. Our choices are the
pixels at positions (xk+1, yk) and (xk+l,
yk+l).
Bresenham's Line Algorithm :
 Bresenham's Line Algorithm :
A decision parameter pk for the kth step in the line algorithm
can be obtained by rearranging Eq. 3-11 so that it involves only
integer calculations.
We accomplish this by substituting m = y / x, where y and
x are the vertical and horizontal separations of the endpoint
positions, and defining:

The sign of pk is the same as the sign of d1 – d2, since x > 0

for our example. Parameter c is constant and has the value
2y + x(2b - l), which is independent of pixel position and will
be eliminated in the recursive calculations for pk. If the pixel at
yk is closer to the line path than the pixel at yk + 1 (that is, d1 <
d2), then decision parameter pk is negative. In that case, we
plot the lower pixel; otherwise, we plot the upper pixel.
Bresenham's Line Algorithm :
 Bresenham's Line Algorithm :
Coordinate changes along the line occur in unit steps in either
the x or y directions. Therefore, we can obtain the values of
successive decision parameters using incremental integer
calculations. At step k + 1, the decision parameter is evaluated
from Eq. 3-12 as
 Bresenham's Line Algorithm :
This recursive calculation of decision parameters is performed
at each integer x position, starting at the left coordinate
endpoint of the line. The first parameter, p0, is evaluated from
Eq. 3-12 at the starting pixel position (x0, y0) and with m
evaluated as y / x:

P0 = 2 y - x …….. ( 3.14 )

We can summarize Bresenham line drawing for a line with a

positive slope less than 1 in the following listed steps. The
constants 2y and 2y - 2x are calculated once for each line
to be scan converted, so the arithmetic involves only integer
addition and subtraction of these two constants.
Bresenham's Line Algorithm :

Pk = ∆X (d1 – d2)

= ∆X (2 m(Xk + 1) - 2 Yk +2b – 1 )

= ∆X (2mXk + 2m - 2 Yk +2b – 1 )

= ∆X (2mX0 + 2m - 2 Y0 +2b – 1 ) [put k=0]

= ∆X (2(mX0 + b - Y0 ) +2m – 1 )

= ∆X(2m – 1) (Because mX0 + b - Y0 =0)

= ∆X (2 ∆Y / ∆X – 1)

P0 = 2 ∆y - ∆X [decision parameter]
Bresenham's Line Algorithm :
Bresenham's Line Algorithm :
Circle-Generating Algorithms:
Circle-Generating Algorithms:
 Circle-Generating Algorithms:
But this is not the best method for generating a circle. One
problem with this approach is that it involves considerable
computation at each step. Moreover, the spacing between
plotted pixel positions is not uniform, as demonstrated in
Fig. 3-13. We could adjust the spacing by interchanging x and y
(stepping through y values and calculating x values) whenever
the absolute value of the slope of the circle is greater than 1.
But this simply increases the computation and processing
required by the algorithm.
Another way to eliminate the unequal spacing shown in
Fig. 3-13 is to calculate points along the circular boundary
using polar coordinates r and  (Fig.3-12). Expressing the circle
equation in parametric polar form yields the pair of equations
 Circle-Generating Algorithms:

When a display is generated with these equations using a fixed

angular step size, a circle is plotted with equally spaced points
along the circumference. The step size chosen for  depends
on the application and the display device. Larger angular
separations along the circumference can be connected with
straight line segments to approximate the circular path. For a
more continuous boundary on a raster display, we can set the
step size at 1/r. This plots pixel positions that are approximately
one unit apart.
 Circle-Generating Algorithms:

Computation can be reduced by considering the symmetry of

circles. The shape of the circle is similar in each quadrant. We can
generate the circle section in the second quadrant of the xy plain
by noting that the two circle sections are symmetric with respect
to the y axis. And circle sections in the third and fourth quadrants
can be obtained from sections in the first and second quadrants
by considering symmetry about the x axis.
We can take this one step further and note that there is also
symmetry between octants. Circle sections in adjacent octants
within one quadrant are symmetric with respect to the 45 0 line
dividing the two octants. These symmetry conditions are
illustrated in Fig.3-14, where a point at position (x, y) on a one-
eighth circle sector is mapped into the seven circle points in the
other octants of the xy plane. Taking advantage of the circle
symmetry in this way we can generate all pixel positions around a
circle by calculating only the points within the sector from x = 0 to
x = y.
 Circle-Generating Algorithms:

Determining pixel positions along a

circle circumference using either Eq.
3-24 or Eq. 3-26 still requires a good
deal of computation time. The
Cartesian equation 3-24 involves
multiplications and square-root
calculations, while the parametric
equations contain multiplications
and trigonometric calculations.
More efficient circle algorithms are
based on incremental calculation of
decision parameters, as in the
Bresenham line algorithm, which
involves only simple integer
operations,
 Circle-Generating Algorithms:

Bresenham's line algorithm for raster displays is adapted to circle

generation by setting up decision parameters for finding the
closest pixel to the circumference at each sampling step. The
circle equation 3-24, however, is nonlinear, so that square-root
evaluations would be required to compute pixel distances from a
circular path. Bresenham's circle algorithm avoids these square-
root calculations by comparing the squares of the pixel separation
distances.
A method for direct distance comparison is to test the halfway
position between two pixels to determine if this midpoint is inside
or outside the circle boundary. This method is more easily applied
to other conics; and for an integer circle radius, the midpoint
approach generates the same pixel positions as the Bresenham
circle algorithm. Also, the error involved in locating pixel positions
along any conic section using the midpoint test is limited to one-
half the pixel separation.
 Midpoint Circle Algorithm:

As in the raster line algorithm, we sample at unit intervals and

determine the closest pixel position to the specified circle path
at each step. For a given radius r and screen center position
(xc, yc), we can first set up our algorithm to calculate pixel
positions around a circle path centered at the coordinate origin
(0,0). Then each calculated position (x, y) is moved to its
proper screen position by adding xc to x and yc to y.
Along the circle section from x = 0 to x = y in the first quadrant,
the slope of the curve varies from 0 to -1. Therefore, we can
take unit steps in the positive x direction over this octant and
use a decision parameter to determine which of the two
possible y positions is closer to the circle path at each step.
Positions of the other seven octants are then obtained by
symmetry.
 Midpoint Circle Algorithm:

To apply the midpoint method, we define a circle function:

fcircle(x, y) = x2 + y2 – r2 ………. ( 3-27)

Any point ( x , y) on the boundary of the circle with radius r

satisfies the equation fcircle(x, y) = 0. If the point is in the interior
of the circle, the circle function is negative. And if the point is
outside the circle, the circle function is positive.
To summarize, the relative position of any point (x. y) can be
determined by checking the sign of the circle function:
Midpoint Circle Algorithm:
 Midpoint Circle Algorithm:

The circle-function tests in 3-28 are performed for the mid

positions between pixels near the circle path at each sampling
step. Thus, the circle function is the decision parameter in the
midpoint algorithm, and we can set up incremental calculations
for this function as we did in the line algorithm.

Figure 3-15 shows the midpoint between the two candidate

pixels at sampling position xk + 1. Assuming we have just
plotted the pixel at (xk, yk), we next need to determine whether
the pixel at position (xk+ 1, yk) or the one at position
(xk + 1, yk - 1) is closer to the circle. Our decision parameter is
the circle function 3-27 evaluated at the midpoint between
these two pixels:
Midpoint Circle Algorithm:
Now find successive decision parameter (Pk +1)

Replace k as k+1 in eq. no (3)

Pk +1 = (Xk+1+1)2 + (Yk+1 – ½)2 – r2

Pk +1 =(Xk +2)2 + (Yk+1 – ½)2 – r2 …(4)

Now,
Pk +1 – Pk = [(Xk +2)2 + (Yk+1 – ½)2 – r2 ] – [(Xk+1)2 + (Yk – ½)2 – r2]

Pk +1 = Pk + 2(Xk +1) + (Y2k+1 - Y2k ) - (Yk+1 - Yk ) + 1 …(5)

Where Yk+1 is either Yk or Yk-1

 if Pk < 0 then midpoint is inside the circle and pixel on scan line Y k is closer to the circle boundary.
So select upper pixel. i.e. Yk

Then from eq. no (5)

Pk +1 = Pk + 2(Xk +1) + (Y2k+1 - Y2k ) - (Yk+1 - Yk ) + 1

Pk +1 = Pk + 2(Xk +1) + (Y2k - Y2k ) - (Yk - Yk ) + 1

= Pk + 2(Xk +1) + 1

Pk +1 = Pk + 2Xk + 3

 Now if Pk ≥ 0 then mid point is on the circle boundary or outside the circle boundary. So select
lower pixel. i.e.Yk-1

Then from eq. no (5)

Pk +1 = Pk + 2(Xk +1) + (Y2k+1 - Y2k ) - (Yk+1 - Yk ) + 1

Pk +1 = Pk + 2(Xk +1) + (Yk -1)2 - Y2k ) - (Yk -1 - Yk ) + 1

Pk +1 = Pk + 2(Xk – Yk ) + 5
 The initial decision parameter is obtained by evaluating the
circle function at the start position ( x0,y0) = (0,r).
First decision parameter coordinate at (0,r)

P0 = fcircle( 1, r – ½ )

P0 = (0 + 1)2 + (r – ½ )2 –r2

P0 = 5/4 – r

but Bresenham algorithm involve only integer value

P0 = 1 – r …(6)
Midpoint Circle Algorithm:
Midpoint Circle Algorithm:
Midpoint Circle Algorithm:
Midpoint Circle Algorithm:
Midpoint Circle Algorithm:
 Character Generation:

Letters, numbers, and other characters can be displayed in a

variety of sizes and styles. The overall design style for a set (or
family) of characters is called a type face. Today, there are
hundreds of typefaces available for computer applications.

Examples of a few common typefaces are Courier, Helvetica,

New York, Palatino, and Zapf Chancery. Originally, the term
font referred to a set of cast metal character forms in a
particular size and format, such as 10-point Courier Italic or 12-
point Palatino Bold. Now, the terms font and typeface are often
used interchangeably, since printing is no longer done with cast
metal forms.
 Character Generation:

Typefaces (or fonts) can be divided into two broad groups: serif
and sans serif. Serif type has small lines or accents at the ends
of the main character strokes, while sans-serif type does not
have accents. For example, the text in this book is set in a serif
font (Palatino). But this sentence is printed in a sans-serif font
(Optima).
Serif type is generally more readable; that is, it is easier to read
in longer blocks of text. On the other hand, the individual
characters in sans-serif type are easier to recognize. For this
reason, sans-serif type is said to be more legible. Since sans-
serif characters can be quickly recognized, this typeface is
good for labeling and short headings.
 Character Generation:

Two different representations are used for storing computer

fonts. A simple method for representing the character shapes in
a particular typeface is to use rectangular grid patterns. The set
of characters are then referred to as a bitmap font (or
bitmapped font).

Another, more flexible, scheme is to describe character shapes

using straight-line and curve sections, as in PostScript, for
example. In this case, the set of characters is called an outline
font. Figure 3-48 illustrates the two methods for character
representation. When the pattern in Fig. 3-48(a) is copied to an
area of the frame buffer, the 1 bits designate which pixel
positions are to be displayed on the monitor.
Character Generation:
 Character Generation:

Bitmap fonts are the simplest to define and display: The

character grid only needs to be mapped to a frame-buffer
position. In general, however, bitmap fonts require more space,
because each variation (size and format) must be stored in a
font cache. It is possible to generate different sizes and other
variations, such as bold and italic, from one set, but this usually
does not produce good results.
In contrast to bitmap fonts, outline fonts require less storage
since each variation does not require a distinct font cache. We
can produce boldface, italic, or different sizes by manipulating
the curve definitions for the character outlines. But it does take
more time to process the outline fonts, because they must be
scan converted into the frame buffer.
Character Generation:
 Character Generation:

A predefined character is then centered at each of the n

coordinate positions in the list wcpoints. The default symbol
displayed by polymarker depends on the particular
implementation, but we assume for now that an asterisk is to
be used. Figure 3-49 illustrates plotting of a data set with the
statement
polymarker (6, wcpoints)
Attributes of Output Primitives
Any parameter that affects the way a primitive is to be displayed is
referred to as an attribute parameter. Some attribute parameters, such
as color and size, determine the fundamental characteristics of a
primitive. Others specify how the primitive is to be displayed under
special conditions. Examples of attributes in this class include depth
information for three-dimensional viewing and visibility or
detectability options for interactive object-selection programs.

Here, we consider only those attributes that control the basic display
properties of primitives, without regard for special situations. For
example, lines can be dotted or dashed, fat or thin, and blue or
orange. Areas might be filled with one color or with a multicolor
pattern. Text can appear reading from left to right, slanted diagonally
across the screen, or in vertical columns. Individual characters can be
displayed in different fonts, colors, and sizes. And we can apply
intensity variations at the edges of objects to smooth out the raster
stairstep effect.
Attributes of Output Primitives

 With GKS and PHIGS standards, attributes

settings are accomplished with separate
functions that updates a system attribute list.
 Four types of attributes:
1. Line Attribute
2. Color And Grayscale Level Attribute
3. Area Fill Attribute
4. Character Attributes
 Line Attribute
There are three basic Line Attributes :
1. Line type (Solid, Dashed, Dotted)
2. Line width
3. Line color
A dashed line could be displayed by generating an interdash
spacing that is equal to the length of the solid sections. Both the
length of the dashes and the interdash spacing are often
specified as user options. A dotted line can be displayed by
generating very short dashes with the spacing equal to or
greater than the dash size. Similar methods are used to
produce other line-type variations.
1. Line Types:
 2. Line Width :
 The implementation of line width option depends on the capabilities
of the output devices.
 In Raster Scan, a standard width is generated with single pixel at
each sample position.
 In raster scan, the lines of width > 1 are drawn by plotting the
additional pixel which are adjacent to the line.
 If the width is 2, the line with (x,y) values is drawn with one more
line with (x,y+1) values.
 If lw is greater than 2, we select alternatively, the lines to right and
left of the standard line.
Problems:

1. The horizontal and vertical lines can be perfectly

drawn, but the diagonal lines will be drawn thinner.
2. Another problem is that the shape of line at the
ends is horizontal or vertical regardless of the
slope of the line.
Solution:
We can adjust the shape of line ends by using the line
caps.
Line caps: Three types of line caps.
1. Butt cap
2. Round cap
3. Projection square cap
Butt cap: Butt cap is obtained by adjusting the end position of the
component parallel lines, so that the thick line is displayed with square
ends that are perpendicular to the line path.
Round cap : Obtained by adding a filled semicircle to each butt cap. The
circular arcs are centered on the line endpoints and have a diameter
equal to the line thickness.
Projecting square cap: Obtained by extending the line, and adding butt cap
That are positioned one-half of the line width beyond the specified
endpoints.
 Displaying thick lines using horizontal and vertical pixel spans,
leaves pixel gaps at the boundaries between lines of different
slopes where there is a shift from horizontal spans to vertical
spans.
 When two thick lines are intersecting, then also we may want to set
the join into required shape. The three types of joins are as
below:
1. Miter join
2. Round join
3. Bevel join
1. Miter join: Accomplished by extending the outer boundary of each
of the two line until they meet.
2. Round join: It is produced by capping the connection
between the two segments with a circular boundary
whose diameter is equal to the line-width.

3. Bevel join: It is generated by displaying the line

segment with butt caps and filling the triangular gap
where the segments meet.
 3. Line color : When a system provides color (or
intensity) options, a parameter giving the current color
index is included in the list of system-attribute values. A
polyline routine displays a line in the current color by
setting this color value in the frame buffer at pixel
locations along the line path using the setpixel
procedure. The number of color choices depends on
the number of bits available per pixel in the frame buffer.