CG Unit 1 Notes
CG Unit 1 Notes
UNIT I - 2D PRIMITIVES
Introduction
A picture is completely specified by the set of intensities for the pixel positions in the
display. Shapes and colors of the objects can be described internally with pixel arrays
into the frame buffer or with the set of the basic geometric – structure such as straight
line segments and polygon color areas. To describe structure of basic object is referred to
as output primitives.
Each output primitive is specified with input co-ordinate data and other information about
the way that objects is to be displayed. Additional output primitives that can be used to
constant a picture include circles and other conic sections, quadric surfaces, Spline curves
and surfaces, polygon floor areas and character string.
Line drawing is accomplished by calculating intermediate positions along the line path
between two specified end points positions. An output device is then directed to fill in
these positions between the end points
Digital devices display a straight line segment by plotting discrete points between the two
end points. Discrete coordinate positions along the line path are calculated from the
equation of the line. For a raster video display, the line color (intensity) is then loaded
into the frame buffer at the corresponding pixel coordinates. Reading from the frame
buffer, the video controller then plots “the screen pixels”.
Pixel positions are referenced according to scan-line number and column number (pixel
position across a scan line). Scan lines are numbered consecutively from 0, starting at the
bottom of the screen; and pixel columns are numbered from 0, left to right across each
scan line
1
CS2401 –Computer Graphics Unit - I
Figure : Pixel Postions reference by scan line number and column number
To load an intensity value into the frame buffer at a position corresponding to column x
along scan line y,
setpixel (x, y)
To retrieve the current frame buffer intensity setting for a specified location we use a low
level function
getpixel (x, y)
y=m.x+b (1)
Given that the two endpoints of a line segment are specified at positions (x1,y1) and
(x2,y2) as in figure we can determine the values for the slope m and y intercept b with the
following calculations
2
CS2401 –Computer Graphics Unit - I
m = ∆y / ∆x = y2-y1 / x2 - x1 (2)
b= y1 - m . x1 (3)
For any given x interval ∆x along a line, we can compute the corresponding y interval
∆y
∆y= m ∆x (4)
∆ x = ∆ y/m (5)
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 (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 (5)
For lines with m = 1, ∆x = ∆y and the horizontal and vertical deflections voltage
are equal.
Figure : Straight line Segment with five sampling positions along the x axis between x1 and x2
3
CS2401 –Computer Graphics Unit - I
The line at unit intervals in one coordinate and determine corresponding integer values
nearest the line path for the other coordinate.
A line with positive slop, if the slope is less than or equal to 1, at unit x intervals (∆x=1)
and compute each successive y values as
yk+1 = yk + m (6)
Subscript k takes integer values starting from 1 for the first point and increases by 1 until
the final endpoint is reached. m can be any real number between 0 and 1 and, the
calculated y values must be rounded to the nearest integer
For lines with a positive slope greater than 1 we reverse the roles of x and y, (∆y=1) and
calculate each succeeding x value as
Equation (6) and (7) are based on the assumption that lines are to be processed from the
left endpoint to the right endpoint.
If this processing is reversed, ∆x=-1 that the starting endpoint is at the right
yk+1 = yk – m (8)
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. (6)
When the start endpoint is at the right (for the same slope), we set ∆x = -1 and obtain y
positions from Eq. (8). Similarly, when the absolute value of a negative slope is greater
than 1, we use ∆y = -1 and Eq. (9) or we use ∆y = 1 and Eq. (7).
4
CS2401 –Computer Graphics Unit - I
Algorithm
Algorithm Description:
7. Iterate the calculation for xIncrement and yIncrement for steps(6) number of times
8. Tabulation of the each iteration
Plotting points
k x Y
(Rounded to Integer)
0 0+0.66=0.66 0+1=1 (1,1)
1 0.66+0.66=1.32 1+1=2 (1,2)
2 1.32+0.66=1.98 2+1=3 (2,3)
3 1.98+0.66=2.64 3+1=4 (3,4)
4 2.64+0.66=3.3 4+1=5 (3,5)
5 3.3+0.66=3.96 5+1=6 (4,6)
Result :
An accurate and efficient raster line generating algorithm developed by Bresenham, that
uses only incremental integer calculations.
6
CS2401 –Computer Graphics Unit - I
In addition, Bresenham’s line algorithm can be adapted to display circles and other
curves.
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.
To determine the pixel (xk,yk) is to be displayed, next to decide which pixel to plot the
column xk+1=xk+1.(xk+1,yk) and .(xk+1,yk+1). At sampling position xk+1, we label vertical
pixel separations from the mathematical line path as d1 and d2. The y coordinate on the
mathematical line at pixel column position xk+1 is calculated as
y =m(xk+1)+b (1)
Then
d1 = y-yk
= m(xk+1)+b-yk
d2 = (yk+1)-y
= yk+1-m(xk+1)-b
To determine which of the two pixel is closest to the line path, efficient test that is based
on the difference between the two pixel separations
A decision parameter Pk for the kth step in the line algorithm can be obtained by
rearranging equation (2). By substituting m=∆y/∆x where ∆x and ∆y are the vertical and
horizontal separations of the endpoint positions and defining the decision parameter as
pk = ∆x (d1- d2)
= 2∆y xk.-2∆x. yk + c (3)
Parameter C is constant and has the value 2∆y + ∆x(2b-1) which is independent of the
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 (d1< d2) than decision
parameter Pk is negative. In this case, plot the lower pixel, otherwise plot the upper pixel.
Coordinate changes along the line occur in unit steps in either the x or y directions.
7
CS2401 –Computer Graphics Unit - I
The first parameter P0 is evaluated from equation at the starting pixel position
(x0,y0) and with m evaluated as ∆y/∆x
P0 = 2∆y-∆x (5)
Bresenham’s line drawing for a line with a positive slope less than 1 in the following
outline of the algorithm.
The constants 2∆y and 2∆y-2∆x are calculated once for each line to be scan
converted.
1. Input the two line endpoints and store the left end point in (x0,y0)
2. load (x0,y0) into frame buffer, ie. Plot the first point.
3. Calculate the constants ∆x, ∆y, 2∆y and obtain the starting value for the decision
parameter as P0 = 2∆y-∆x
4. At each xk along the line, starting at k=0 perform the following test
If Pk < 0, the next point to plot is(xk+1,yk) and
Pk+1 = Pk + 2∆y
otherwise, the next point to plot is (xk+1,yk+1) and
Pk+1 = Pk + 2∆y - 2∆x
8
CS2401 –Computer Graphics Unit - I
if (xa > x b )
{
x = xb;
y = yb;
xEnd = xa;
}
else
{
x = xa;
y = ya;
xEnd = xb;
}
setPixel(x,y);
while(x<xEnd)
{
x++;
if (p<0)
p+=twoDy;
else
{
y++;
p+=twoDyDx;
}
setPixel(x,y);
}
}
9
CS2401 –Computer Graphics Unit - I
∆x = 10 ∆y=8
p0 = 2Δy- Δx = 6
We plot the initial point (x0,y0) = (20,10) and determine successive pixel positions along
the line path from the decision parameter as
Tabulation
k pk (xk+1, yK+1)
0 6 (21,11)
1 2 (22,12)
2 -2 (23,12)
3 14 (24,13)
4 10 (25,14)
5 6 (26,15)
6 2 (27,16)
7 -2 (28,16)
8 14 (29,17)
9 10 (30,18)
Result
10
CS2401 –Computer Graphics Unit - I
Advantages
Algorithm is Fast
Uses only integer calculations
Disadvantages
Line Function
To display a single straight-line segment we have to set n=2 and list the x and y values of
the two endpoint coordinates in wcPoints.
Circle-Generating Algorithms
General function is available in a graphics library for displaying various kinds of curves,
including circles and ellipses.
Properties of a circle
A circle is defined as a set of points that are all the given distance (xc,yc).
11
CS2401 –Computer Graphics Unit - I
This is not the best method for generating a circle for the following reason
To eliminate the unequal spacing is to calculate points along the circle boundary using
polar coordinates r and θ. Expressing the circle equation in parametric polar from yields
the pair of equations
x = xc + rcos θ y = yc + rsin θ
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. To reduce calculations use
a large angular separation between points along the circumference and connect the points
with straight line segments to approximate the circular path.
Set the angular step size at 1/r. This plots pixel positions that are approximately
one unit apart. The shape of the circle is similar in each quadrant. To determine the curve
positions in the first quadrant, to generate he circle section in the second quadrant of the
xy plane by nothing that the two circle sections are symmetric with respect to the y axis
12
CS2401 –Computer Graphics Unit - I
and circle section in the third and fourth quadrants can be obtained from sections in the
first and second quadrants by considering symmetry between octants.
Circle sections in adjacent octants within one quadrant are symmetric with respect to the
450 line dividing the two octants. Where a point at position (x, y) on a one-eight circle
sector is mapped into the seven circle points in the other octants of the xy plane.
To generate all pixel positions around a circle by calculating only the points within the
sector from x=0 to y=0. the slope of the curve in this octant has an magnitude less than of
equal to 1.0. at x=0, the circle slope is 0 and at x=y, the slope is -1.0.
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. Square root evaluations would be required to computer pixel siatances from a
circular path.
In this approach 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.
For a straight line segment the midpoint method is equivalent to the bresenham line
algorithm. The error involved in locating pixel positions along any conic section using
the midpoint test is limited to one half the pixel separations.
13
CS2401 –Computer Graphics Unit - I
In the raster line algorithm 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) set up our algorithm to calculate pixel positions around a circle path
centered at the coordinate position by adding xc to x and yc to y.
To apply the midpoint method we define a circle function as
fcircle(x,y) = x2+y2-r2
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
The tests in the above eqn are performed for the midposition sbteween pixels near the
circle path at each sampling step. The circle function is the decision parameter in the
midpoint algorithm.
Midpoint between candidate pixels at sampling position xk+1 along a circular path.
Fig -1 shows the midpoint between the two candidate pixels at sampling position xk+1. To
plot the pixel at (xk,yk) next need to determine whether the pixel at position (xk+1,yk) or
the one at position (xk+1,yk-1) is circular to the circle.
Our decision parameter is the circle function evaluated at the midpoint between
these two pixels
Pk= fcircle (xk+1,yk-1/2)
=(xk+1)2+(yk-1/2)2-r2
If Pk <0, this midpoint is inside the circle and the pixel on scan line yk is closer to the
circle boundary. Otherwise the mid position is outside or on the circle boundary and
select the pixel on scan line yk -1.
14
CS2401 –Computer Graphics Unit - I
Evaluation of the terms 2xk+1 and 2 yk+1 can also be done incrementally as
2xk+1=2xk+2
2 yk+1=2 yk-2
At the Start position (0,r) these two terms have the values 0 and 2r respectively. Each
successive value for the 2xk+1 term is obtained by adding 2 to the previous value and each
successive value for the 2yk+1 term is obtained by subtracting 2 from the previous value.
The initial decision parameter is obtained by evaluating the circle function at the
start position (x0,y0)=(0,r)
P0=1-r(for r an integer)
1. Input radius r and circle center (xc,yc) and obtain the first point on the circumference
of the circle centered on the origin as
(x0,y0) = (0,r)
2. Calculate the initial value of the decision parameter as P0=(5/4)-r
3. At each xk position, starting at k=0, perform the following test. If Pk <0 the next point
along the circle centered on (0,0) is (xk+1,yk) and Pk+1=Pk+2xk+1+1
Otherwise the next point along the circle is (xk+1,yk-1) and Pk+1=Pk+2xk+1+1-2 yk+1
Where 2xk+1=2xk+2 and 2yk+1=2yk-2
4. Determine symmetry points in the other seven octants.
5. Move each calculated pixel position (x,y) onto the circular path centered at (xc,yc) and
plot the coordinate values.
x=x+xc y=y+yc
6. Repeat step 3 through 5 until x>=y.
15
CS2401 –Computer Graphics Unit - I
The circle octant in the first quadrant from x=0 to x=y. The initial value of the decision
parameter is P0=1-r = - 9
For the circle centered on the coordinate origin, the initial point is (x0,y0)=(0,10) and
initial increment terms for calculating the decision parameters are
2x0=0 , 2y0=20
16
CS2401 –Computer Graphics Unit - I
Ellipse-Generating Algorithms
17
CS2401 –Computer Graphics Unit - I
Properties of ellipses
An ellipse can be given in terms of the distances from any point on the ellipse to two
fixed positions called the foci of the ellipse. The sum of these two distances is the same
values for all points on the ellipse.
If the distances to the two focus positions from any point p=(x,y) on the ellipse are
labeled d1 and d2, then the general equation of an ellipse can be stated as
d1+d2=constant
By squaring this equation isolating the remaining radical and squaring again. The
general ellipse equation in the form
Ax2+By2+Cxy+Dx+Ey+F=0
The coefficients A,B,C,D,E, and F are evaluated in terms of the focal coordinates and the
dimensions of the major and minor axes of the ellipse.
The major axis is the straight line segment extending from one side of the ellipse
to the other through the foci. The minor axis spans the shorter dimension of the ellipse,
perpendicularly bisecting the major axis at the halfway position (ellipse center) between
the two foci.
Ellipse equations are simplified if the major and minor axes are oriented to align
with the coordinate axes. The major and minor axes oriented parallel to the x and y axes
parameter rx for this example labels the semi major axis and parameter r y labels the semi
minor axis
18
CS2401 –Computer Graphics Unit - I
((x-xc)/rx)2+((y-yc)/ry)2=1
Using polar coordinates r and θ, to describe the ellipse in Standard position with
the parametric equations
x=xc+rxcos θ
y=yc+rxsin θ
Angle θ called the eccentric angle of the ellipse is measured around the perimeter of a
bounding circle.
We must calculate pixel positions along the elliptical arc throughout one quadrant, and
then we obtain positions in the remaining three quadrants by symmetry
The midpoint ellipse method is applied throughout the first quadrant in two parts.
The below figure show the division of the first quadrant according to the slope of an
ellipse with rx<ry.
19
CS2401 –Computer Graphics Unit - I
In the x direction where the slope of the curve has a magnitude less than 1 and unit steps
in the y direction where the slope has a magnitude greater than 1.
1. Start at position (0,ry) and step clockwise along the elliptical path in the first
quadrant shifting from unit steps in x to unit steps in y when the slope becomes less than
-1
2. Start at (rx,0) and select points in a counter clockwise order.
2.1 Shifting from unit steps in y to unit steps in x when the slope becomes
greater than -1.0
2.2 Using parallel processors calculate pixel positions in the two regions
simultaneously
3. Start at (0,ry)
step along the ellipse path in clockwise order throughout the first quadrant
ellipse function (xc,yc)=(0,0)
fellipse (x,y)=ry2x2+rx2y2 –rx2 ry2
which has the following properties:
fellipse (x,y) <0, if (x,y) is inside the ellipse boundary
=0, if(x,y) is on ellipse boundary
>0, if(x,y) is outside the ellipse boundary
Thus, the ellipse function fellipse (x,y) serves as the decision parameter in the
midpoint algorithm.
Starting at (0,ry):
Unit steps in the x direction until to reach the boundary between region 1 and
region 2. Then switch to unit steps in the y direction over the remainder of the curve in
the first quadrant.
20
CS2401 –Computer Graphics Unit - I
At each step to test the value of the slope of the curve. The ellipse slope is
calculated
dy/dx= -(2ry2x/2rx2y)
2ry2x>=2rx2y
The following figure shows the midpoint between two candidate pixels at sampling
position xk+1 in the first region.
To determine the next position along the ellipse path by evaluating the decision
parameter at this mid point
if P1k <0, the midpoint is inside the ellipse and the pixel on scan line yk is
closer to the ellipse boundary. Otherwise the midpoint is outside or on the ellipse
boundary and select the pixel on scan line yk-1
At the next sampling position (xk+1+1=xk+2) the decision parameter for region 1 is
calculated as
21
CS2401 –Computer Graphics Unit - I
Or
p1k+1 = p1k +2 ry2(xk +1) + ry2 + rx2 [(yk+1 -½)2 - (yk -½)2]
Increments for the decision parameters can be calculated using only addition and
subtraction as in the circle algorithm.
The terms 2ry2 x and 2rx2 y can be obtained incrementally. At the initial position
(0,ry) these two terms evaluate to
2 ry2x = 0
2rx2 y =2rx2 ry
x and y are incremented updated values are obtained by adding 2ry2to the current
value of the increment term and subtracting 2rx2 from the current value of the increment
term. The updated increment values are compared at each step and more from region 1 to
region 2. when the condition 4 is satisfied.
In region 1 the initial value of the decision parameter is obtained by evaluating the
ellipse function at the start position
(x0,y0) = (0,ry)
region 2 at unit intervals in the negative y direction and the midpoint is now taken
between horizontal pixels at each step for this region the decision parameter is evaluated
as
p10 = fellipse(1,ry -½ )
22
CS2401 –Computer Graphics Unit - I
Or
over region 2, we sample at unit steps in the negative y direction and the midpoint is now
taken between horizontal pixels at each step. For this region, the decision parameter is
evaluated as
1. If P2k >0, the mid point position is outside the ellipse boundary, and select the
pixel at xk.
2. If P2k <=0, the mid point is inside the ellipse boundary and select pixel position
xk+1.
To determine the relationship between successive decision parameters in region 2
evaluate the ellipse function at the sampling step : yk+1 -1= yk-2.
or
p2k+1 = p2k -2 rx2(yk -1) + rx2 + ry2 [(xk+1 +½)2 - (xk +½)2]
With xk+1set either to xkor xk+1, depending on the sign of P2k. when we enter
region 2, the initial position (x0,y0) is taken as the last position. Selected in region 1 and
the initial decision parameter in region 2 is then
To simplify the calculation of P20, select pixel positions in counter clock wise
order starting at (rx,0). Unit steps would then be taken in the positive y direction up to the
last position selected in region 1.
1. Input rx,ry and ellipse center (xc,yc) and obtain the first point on an ellipse
centered on the origin as
23
CS2401 –Computer Graphics Unit - I
(x0,y0) = (0,ry)
Otherwise the next point along the ellipse is (xk+1, yk-1) and
with
4. Calculate the initial value of the decision parameter in region 2 using the last
point (x0,y0) is the last position calculated in region 1.
24
CS2401 –Computer Graphics Unit - I
Input ellipse parameters rx=8 and ry=6 the mid point ellipse algorithm by
determining raster position along the ellipse path is the first quadrant. Initial
values and increments for the decision parameter calculations are
2ry2 x=0 (with increment 2ry2=72 )
2rx2 y=2rx2 ry (with increment -2rx2= -128 )
For region 1 the initial point for the ellipse centered on the origin is (x0,y0) =
(0,6) and the initial decision parameter value is
p10=ry2-rx2ry2+1/4rx2=-332
Successive midpoint decision parameter values and the pixel positions along the
ellipse are listed in the following table.
For a region 2 the initial point is (x0,y0)=(7,3) and the initial decision parameter
is
p20 = fellipse(7+1/2,2) = -151
The remaining positions along the ellipse path in the first quadrant are then
calculated as
25
CS2401 –Computer Graphics Unit - I
/ * Region 1 */
p = ROUND(Ry2 - (Rx2* Ry) + (0.25*Rx2));
while (px < py)
{
x++;
px += twoRy2;
i f (p < 0)
p += Ry2 + px;
else
{
y--;
py -= twoRx2;
p += Ry2 + px - py;
}
ellipsePlotPoints(xCenter, yCenter,x,y);
}
/* Region 2 */
p = ROUND (Ry2*(x+0.5)*' (x+0.5)+ Rx2*(y- l )* (y- l ) - Rx2*Ry2);
while (y > 0 )
{
y--;
py -= twoRx2;
i f (p > 0)
p += Rx2 - py;
else
26
CS2401 –Computer Graphics Unit - I
{
x++;
px+=twoRy2;
p+=Rx2-py+px;
}
ellipsePlotPoints(xCenter, yCenter,x,y);
}
}
void ellipsePlotPoints(int xCenter, int yCenter,int x,int y);
{
setpixel (xCenter + x, yCenter + y);
setpixel (xCenter - x, yCenter + y);
setpixel (xCenter + x, yCenter - y);
setpixel (xCenter- x, yCenter - y);
}
1. Line Attributes
2. Curve Attributes
3. Color and Grayscale Levels
4. Area Fill Attributes
5. Character Attributes
6. Bundled Attributes
27
CS2401 –Computer Graphics Unit - I
Line Attributes
Basic attributes of a straight line segment are its type, its width, and its color. In some
graphics packages, lines can also be displayed using selected pen or brush options
Line Type
Line Width
Pen and Brush Options
Line Color
Line type
Possible selection of line type attribute includes solid lines, dashed lines and dotted lines.
To set line type attributes in a PHIGS application program, a user invokes the function
setLinetype (lt)
Line width
Implementation of line width option depends on the capabilities of the output device to
set the line width attributes.
setLinewidthScaleFactor(lw)
Line width parameter lw is assigned a positive number to indicate the relative width of
line to be displayed. A value of 1 specifies a standard width line. A user could set lw to a
value of 0.5 to plot a line whose width is half that of the standard line. Values greater
than 1 produce lines thicker than the standard.
Line Cap
We can adjust the shape of the line ends to give them a better appearance by adding line
caps.
28
CS2401 –Computer Graphics Unit - I
Butt cap obtained by adjusting the end positions 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 extend the line and add butt caps that are positioned one-half of
the line width beyond the specified endpoints.
Mitter Join
Round Join
Bevel Join
1. A miter join accomplished by extending the outer boundaries of each of the two lines
until they meet.
2. A round join is produced by capping the connection between the two segments with a
circular boundary whose diameter is equal to the width.
3. A bevel join is generated by displaying the line segment with but caps and filling in tri
angular gap where the segments meet
29
CS2401 –Computer Graphics Unit - I
With some packages, lines can be displayed with pen or brush selections. Options in this
category include shape, size, and pattern. Some possible pen or brush shapes are given in
Figure
Line color
A poly line 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 set pixel procedure.
We set the line color value in PHlGS with the function
setPolylineColourIndex (lc)
Nonnegative integer values, corresponding to allowed color choices, are assigned to the
line color parameter lc
30
CS2401 –Computer Graphics Unit - I
setLinetype(2);
setLinewidthScaleFactor(2);
setPolylineColourIndex (5);
polyline(n1,wc points1);
setPolylineColorIindex(6);
poly line (n2, wc points2);
This program segment would display two figures, drawn with double-wide dashed lines.
The first is displayed in a color corresponding to code 5, and the second in color 6.
Curve attributes
Parameters for curve attribute are same as those for line segments. Curves displayed with
varying colors, widths, dot –dash patterns and available pen or brush options
Various color and intensity-level options can be made available to a user, depending on
the capabilities and design objectives of a particular system
In a color raster system, the number of color choices available depends on the amount of
storage provided per pixel in the frame buffer
With the direct storage scheme, whenever a particular color code is specified in an
application program, the corresponding binary value is placed in the frame buffer for
each-component pixel in the output primitives to be displayed in that color.
A minimum number of colors can be provided in this scheme with 3 bits of storage per
pixel, as shown in Table
31
CS2401 –Computer Graphics Unit - I
Color tables(Color Lookup Tables) are an alternate means for providing extended color
capabilities to a user without requiring large frame buffers
A user can set color-table entries in a PHIGS applications program with the function
32
CS2401 –Computer Graphics Unit - I
Parameter ws identifies the workstation output device; parameter ci specifies the color
index, which is the color-table position number (0 to 255) and parameter colorptr points
to a trio of RGB color values (r, g, b) each specified in the range from 0 to 1
Grayscale
With monitors that have no color capability, color functions can be used in an application
program to set the shades of gray, or grayscale, for displayed primitives. Numeric values
over the range from 0 to 1 can be used to specify grayscale levels, which are then
converted to appropriate binary codes for storage in the raster.
Intensity = 0.5[min(r,g,b)+max(r,g,b)]
Options for filling a defined region include a choice between a solid color or a
pattern fill and choices for particular colors and patterns
Fill Styles
Areas are displayed with three basic fill styles: hollow with a color border, filled with a
solid color, or filled with a specified pattern or design. A basic fill style is selected in a
PHIGS program with the function
setInteriorStyle(fs)
Values for the fill-style parameter fs include hollow, solid, and pattern. Another value for
fill style is hatch, which is used to fill an area with selected hatching patterns-parallel
lines or crossed lines
33
CS2401 –Computer Graphics Unit - I
The color for a solid interior or for a hollow area outline is chosen with where fill color
parameter fc is set to the desired color code
setInteriorColourIndex(fc)
Pattern Fill
We select fill patterns with setInteriorStyleIndex (pi) where pattern index parameter pi
specifies a table position
For example, the following set of statements would fill the area defined in the fillArea
command with the second pattern type stored in the pattern table:
SetInteriorStyle( pattern)
SetInteriorStyleIndex(2);
Fill area (n, points)
34
CS2401 –Computer Graphics Unit - I
Character Attributes
The appearance of displayed character is controlled by attributes such as font, size, color
and orientation. Attributes can be set both for entire character strings (text) and for
individual characters defined as marker symbols
Text Attributes
The choice of font or type face is set of characters with a particular design style as
courier, Helvetica, times roman, and various symbol groups.
The characters in a selected font also be displayed with styles. (solid, dotted,
double) in bold face in italics, and in or shadow styles.
setTextFont(tf)
Control of text color (or intensity) is managed from an application program with
setTextColourIndex(tc)
Text size can be adjusted without changing the width to height ratio of characters with
SetCharacterHeight (ch)
Parameter ch is assigned a real value greater than 0 to set the coordinate height of capital
letters
SetCharacterExpansionFactor(cw)
35
CS2401 –Computer Graphics Unit - I
Where the character width parameter cw is set to a positive real value that scales the body
width of character
setCharacterSpacing(cs)
The orientation for a displayed character string is set according to the direction of the
character up vector
setCharacterUpVector(upvect)
Parameter upvect in this function is assigned two values that specify the x and y vector
components. For example, with upvect = (1, 1), the direction of the up vector is 45o and
text would be displayed as shown in Figure.
setTextPath (tp)
36
CS2401 –Computer Graphics Unit - I
Where the text path parameter tp can be assigned the value: right, left, up, or down
Another handy attribute for character strings is alignment. This attribute specifies how
text is to be positioned with respect to the $tart coordinates. Alignment attributes are set
with
setTextAlignment (h,v)
where parameters h and v control horizontal and vertical alignment. Horizontal alignment
is set by assigning h a value of left, center, or right. Vertical alignment is set by
assigning v a value of top, cap, half, base or bottom.
setTextPrecision (tpr)
Marker Attributes
A marker symbol is a single character that can he displayed in different colors and in
different sizes. Marker attributes are implemented by procedures that load the chosen
character into the raster at the defined positions with the specified color and size. We
select a particular character to be the marker symbol with
setMarkerType(mt)
where marker type parameter mt is set to an integer code. Typical codes for marker type
are the integers 1 through 5, specifying, respectively, a dot (.) a vertical cross (+), an
asterisk (*), a circle (o), and a diagonal cross (X).
37
CS2401 –Computer Graphics Unit - I
setMarkerSizeScaleFactor(ms)
with parameter marker size ms assigned a positive number. This scaling parameter is
applied to the nominal size for the particular marker symbol chosen. Values greater than
1 produce character enlargement; values less than 1 reduce the marker size.
setPolymarkerColourIndex(mc)
A selected color code parameter mc is stored in the current attribute list and used to
display subsequently specified marker primitives
Bundled Attributes
The procedures considered so far each function reference a single attribute that specifies
exactly how a primitive is to be displayed these specifications are called individual
attributes.
A particular set of attributes values for a primitive on each output device is chosen by
specifying appropriate table index. Attributes specified in this manner are called bundled
attributes. The choice between a bundled or an unbundled specification is made by setting
a switch called the aspect source flag for each of these attributes
where parameter attributer ptr points to a list of attributes and parameter flagptr points to
the corresponding list of aspect source flags. Each aspect source flag can be assigned a
value of individual or bundled.
Entries in the bundle table for line attributes on a specified workstation are set with the
function
Parameter ws is the workstation identifier and line index parameter li defines the bundle
table position. Parameter lt, lw, tc are then bundled and assigned values to set the line
type, line width, and line color specifications for designated table index.
38
CS2401 –Computer Graphics Unit - I
Example
setPolylineRepresentation(1,3,2,0.5,1)
setPolylineRepresentation (4,3,1,1,7)
A poly line that is assigned a table index value of 3 would be displayed using
dashed lines at half thickness in a blue color on work station 1; while on workstation 4,
this same index generates solid, standard-sized white lines
Which defines the attributes list corresponding to fill index fi on workstation ws.
Parameter fs, pi and fc are assigned values for the fill style pattern index and fill color.
bundles values for text font, precision expansion factor size an color in a table position
for work station ws that is specified by value assigned to text index parameter ti.
That defines marker type marker scale factor marker color for index mi on
workstation ws.
Inquiry functions
Current settings for attributes and other parameters as workstations types and status in the
system lists can be retrieved with inquiry functions.
inquireInteriorcColourIndex (lastfc)
Copy the current values for line index and fill color into parameter lastli and lastfc.
39
CS2401 –Computer Graphics Unit - I
Changes in orientations, size and shape are accomplished with geometric transformations
that alter the coordinate description of objects.
Basic transformation
Translation
T(tx, ty)
Translation distances
Scale
S(sx,sy)
Scale factors
Rotation
R( )
Rotation angle
Translation
x’ = x + tx, y’ = y + ty
40
CS2401 –Computer Graphics Unit - I
The translation distance point (tx,ty) is called translation vector or shift vector.
Translation equation can be expressed as single matrix equation by using column vectors
to represent the coordinate position and the translation vector as
P ( x, y )
T (t x , t y )
x' x t x
y' y t y
x' x tx
y' y ty
P' P T
Moving a polygon from one position to another position with the translation
vector (-5.5, 3.75)
Rotations:
Positive values for the rotation angle define counter clock wise rotation about
pivot point. Negative value of angle rotate objects in clock wise direction. The
transformation can also be described as a rotation about a rotation axis perpendicular to
xy plane and passes through pivot point
41
CS2401 –Computer Graphics Unit - I
Rotation of a point from position (x,y) to position (x’,y’) through angle θ relative to
coordinate origin
The transformation equations for rotation of a point position P when the pivot point is at
coordinate origin. In figure r is constant distance of the point positions Ф is the original
angular of the point from horizontal and θ is the rotation angle.
x = rcosФ, y = rsinФ
the transformation equation for rotating a point at position (x,y) through an angle θ about
origin
x’ = xcosθ – ysinθ
y’ = xsinθ + ycosθ
Rotation equation
P’= R . P
Rotation Matrix
cos sin
R=
sin cos
42
CS2401 –Computer Graphics Unit - I
Note : Positive values for the rotation angle define counterclockwise rotations about the
rotation point and negative values rotate objects in the clockwise.
Scaling
A scaling transformation alters the size of an object. This operation can be carried out for
polygons by multiplying the coordinate values (x,y) to each vertex by scaling factor Sx &
Sy to produce the transformed coordinates (x’,y’)
x' sx 0 x
y' 0 sy y
or
P’ = S. P
Turning a square (a) Into a rectangle (b) with scaling factors sx = 2 and sy= 1.
Any positive numeric values are valid for scaling factors sx and sy. Values less than 1
reduce the size of the objects and values greater than 1 produce an enlarged object.
43
CS2401 –Computer Graphics Unit - I
Uniform scaling
Non Uniform Scaling
To get uniform scaling it is necessary to assign same value for sx and sy. Unequal values
for sx and sy result in a non uniform scaling.
x' 1 0 tx x
y' 0 1 ty y
1 0 0 1 1
P' T t x , t y P
For Scaling
x' sx 0 0 x
y' 0 sy 0 y
1 0 0 1 1
P' S sx , s y P
44
CS2401 –Computer Graphics Unit - I
For rotation
Composite Transformations
Translation
If two successive translation vectors (tx1,ty1) and (tx2,ty2) are applied to a coordinate
position P, the final transformed location P’ is calculated as
P’=T(tx2,ty2).{T(tx1,ty1).P}
={T(tx2,ty2).T(tx1,ty1)}.P
Or
T(tx2,ty2).T(tx1,ty1) = T(tx1+tx2,ty1+ty2)
Rotations
P’=R(θ2).{R(θ1).P}={R(θ2).R(θ1)}.P
45
CS2401 –Computer Graphics Unit - I
By multiplying the two rotation matrices, we can verify that two successive rotation are
additive
So that the final rotated coordinates can be calculated with the composite rotation matrix
as
P’ = R(θ1+ θ2).P
Scaling
sx 2 0 0 sx1 0 0 sx 2.sx1 0 0
0 sy 2 0 . 0 sy1 0 0 sy 2.sy1 0
0 0 1 0 0 1 0 0 1
46
CS2401 –Computer Graphics Unit - I
The composite transformation matrix for this sequence is obtain with the concatenation
Translate object so that the fixed point coincides with the coordinate origin
Scale the object with respect to the coordinate origin
Use the inverse translation of step 1 to return the object to its original position
47
CS2401 –Computer Graphics Unit - I
Concatenating the matrices for these three operations produces the required scaling matix
#include <math.h>
#include <graphics.h>
typedef float Matrix3x3 [3][3];
Matrix3x3 thematrix;
48
CS2401 –Computer Graphics Unit - I
49
CS2401 –Computer Graphics Unit - I
Other Transformations
1. Reflection
2. Shear
Reflection
rotating the object 180o about the reflection axis. We can choose an axis of reflection in
the xy plane or perpendicular to the xy plane or coordinate origin
1 0 0
0 1 0
0 0 1
Reflection of an object about the y axis
1 0 0
0 1 0
0 0 1
51
CS2401 –Computer Graphics Unit - I
1 0 0
0 1 0
0 0 1
To obtain transformation matrix for reflection about diagonal y=x the transformation
sequence is
1. Clock wise rotation by 450
2. Reflection about x axis
3. counter clock wise by 450
52
CS2401 –Computer Graphics Unit - I
Reflection about the diagonal line y=x is accomplished with the transformation
matrix
0 1 0
1 0 0
0 0 1
To obtain transformation matrix for reflection about diagonal y=-x the transformation
sequence is
1. Clock wise rotation by 450
2. Reflection about y axis
3. counter clock wise by 450
Reflection about the diagonal line y=-x is accomplished with the transformation
matrix
0 1 0
1 0 0
0 0 1
Shear
A Transformation that slants the shape of an object is called the shear transformation.
Two common shearing transformations are used. One shifts x coordinate values and other
shift y coordinate values. However in both the cases only one coordinate (x or y)
changes its coordinates and other preserves its values.
53
CS2401 –Computer Graphics Unit - I
X- Shear
The x shear preserves the y coordinates, but changes the x values which cause vertical
lines to tilt right or left as shown in figure
1 shx 0
0 1 0
0 0 1
x’ =x+ shx .y
y’ = y
Y Shear
The y shear preserves the x coordinates, but changes the y values which cause horizontal
lines which slope up or down
1 0 0
sh y 1 0
0 0 1
x’ =x
y’ = y+ sh y .x
54
CS2401 –Computer Graphics Unit - I
XY-Shear
x' 1 shx 0 x
y' sh y 1 0 y
1 0 0 1 1
x’ =x+ shx .y
y’ = y+ sh y .x
We can apply x shear and y shear transformations relative to other reference lines. In x
shear transformations we can use y reference line and in y shear we can use x reference
line.
We can generate x-direction shears relative to other reference lines with the
transformation matrix
y’ = y
Example
55
CS2401 –Computer Graphics Unit - I
We can generate y-direction shears relative to other reference lines with the
transformation matrix
x’ =x
Example
56
CS2401 –Computer Graphics Unit - I
The viewing- coordinate reference frame is used to provide a method for setting up
arbitrary orientations for rectangular windows. Once the viewing reference frame is
established, we can transform descriptions in world coordinates to viewing coordinates.
We then define a viewport in normalized coordinates (in the range from 0 to 1) and map
the viewing-coordinate description of the scene to normalized coordinates.
At the final step all parts of the picture that lie outside the viewport are clipped, and the
contents of the viewport are transferred to device coordinates. By changing the position
57
CS2401 –Computer Graphics Unit - I
of the viewport, we can view objects at different positions on the display area of an
output device.
A point at position (xw,yw) in the window is mapped into position (x v,yv) in the associated
view port. To maintain the same relative placement in view port as in window
58
CS2401 –Computer Graphics Unit - I
xv xvmin xw xwmin
=
xvmax xvmin xwmax xwmin
yv yvmin yw ywmin
=
yvmax yvmin ywmax ywmin
solving these expressions for view port position (xv,yv)
xvmax xvmin
xv = xvmin + xw xwmin
xwmax xwmin
yvmax yvmin
yv = yvmin + yw ywmin
ywmax ywmin
1. Perform a scaling transformation using point position of (xw min, yw min) that
scales the window area to the size of view port.
2. Translate the scaled window area to the position of view port. Relative
proportions of objects are maintained if scaling factor are the same(Sx=Sy).
Otherwise world objects will be stretched or contracted in either the x or y direction when
displayed on output device. For normalized coordinates, object descriptions are mapped
to various display devices.
Any number of output devices can be open in particular application and another
window view port transformation can be performed for each open output device. This
mapping called the work station transformation is accomplished by selecting a window
area in normalized apace and a view port are in coordinates of display device.
59
CS2401 –Computer Graphics Unit - I
evaluateViewOrientationMatrix(x0,y0,xv,yv,error, viewMatrix)
where x0,y0 are coordinate of viewing origin and parameter xv, yv are the world
coordinate positions for view up vector.An integer error code is generated if the input
parameters are in error otherwise the view matrix for world-to-viewing transformation is
calculated. Any number of viewing transformation matrices can be defined in an
application.
Here window limits in viewing coordinates are chosen with parameters xwmin, xwmax,
ywmin, ywmax and the viewport limits are set with normalized coordinate positions
xvmin, xvmax, yvmin, yvmax.
60
CS2401 –Computer Graphics Unit - I
The combinations of viewing and window view port mapping for various workstations in
a viewing table with
setViewRepresentation(ws,viewIndex,viewMatrix,viewMappingMatrix,
xclipmin, xclipmax, yclipmin, yclipmax, clipxy)
Where parameter ws designates the output device and parameter view index sets an
integer identifier for this window-view port point. The matrices viewMatrix and
viewMappingMatrix can be concatenated and referenced by viewIndex.
setViewIndex(viewIndex)
where was gives the workstation number. Window-coordinate extents are specified in the
range from 0 to 1 and viewport limits are in integer device coordinates.
Clipping operation
Any procedure that identifies those portions of a picture that are inside or outside of a
specified region of space is referred to as clipping algorithm or clipping. The region
against which an object is to be clipped is called clip window.
Point clipping
Line clipping (Straight-line segment)
Area clipping
Curve clipping
Text clipping
Line and polygon clipping routines are standard components of graphics packages.
61
CS2401 –Computer Graphics Unit - I
Point Clipping
Clip window is a rectangle in standard position. A point P=(x,y) for display, if following
inequalities are satisfied:
where the edges of the clip window (xwmin,xwmax,ywmin,ywmax) can be either the
world-coordinate window boundaries or viewport boundaries. If any one of these four
inequalities is not satisfied, the point is clipped (not saved for display).
Line Clipping
A line clipping procedure involves several parts. First we test a given line segment
whether it lies completely inside the clipping window. If it does not we try to determine
whether it lies completely outside the window . Finally if we can not identify a line as
completely inside or completely outside, we perform intersection calculations with one or
more clipping boundaries.
Process lines through “inside-outside” tests by checking the line endpoints. A line with
both endpoints inside all clipping boundaries such as line from P1 to P2 is saved. A line
with both end point outside any one of the clip boundaries line P3P4 is outside the
window.
62
CS2401 –Computer Graphics Unit - I
All other lines cross one or more clipping boundaries. For a line segment with end points
(x1,y1) and (x2,y2) one or both end points outside clipping rectangle, the parametric
representation
x = x1 + u x2 x1 ,
y = y1 + u y2 y1 , 0 u 1
could be used to determine values of u for an intersection with the clipping boundary
coordinates. If the value of u for an intersection with a rectangle boundary edge is outside
the range of 0 to 1, the line does not enter the interior of the window at that boundary. If
the value of u is within the range from 0 to 1, the line segment does indeed cross into the
clipping area. This method can be applied to each clipping boundary edge in to
determined whether any part of line segment is to displayed.
This is one of the oldest and most popular line-clipping procedures. The method
speeds up the processing of line segments by performing initial tests that reduce the
number of intersections that must be calculated.
Every line endpoint in a picture is assigned a four digit binary code called a region
code that identifies the location of the point relative to the boundaries of the clipping
rectangle.
Binary region codes assigned to line end points according to relative position with
respect to the clipping rectangle.
63
CS2401 –Computer Graphics Unit - I
Regions are set up in reference to the boundaries. Each bit position in region code is used
to indicate one of four relative coordinate positions of points with respect to clip window:
to the left, right, top or bottom. By numbering the bit positions in the region code as 1
through 4 from right to left, the coordinate regions are corrected with bit positions as
bit 1: left
bit 2: right
bit 3: below
bit4: above
A value of 1 in any bit position indicates that the point is in that relative position.
Otherwise the bit position is set to 0. If a point is within the clipping rectangle the region
code is 0000. A point that is below and to the left of the rectangle has a region code of
0101.
Bit values in the region code are determined by comparing endpoint coordinate
values (x,y) to clip boundaries. Bit1 is set to 1 if x <xwmin.
(2) Use the resultant sign bit of each difference calculation to set the corresponding value
in the region code.
Once we have established region codes for all line endpoints, we can quickly determine
which lines are completely inside the clip window and which are clearly outside.
Any lines that are completely contained within the window boundaries have a
region code of 0000 for both endpoints, and we accept
64
CS2401 –Computer Graphics Unit - I
these lines. Any lines that have a 1 in the same bit position in the region codes for each
endpoint are completely outside the clipping rectangle, and we reject these lines.
We would discard the line that has a region code of 1001 for one endpoint and a
code of 0101 for the other endpoint. Both endpoints of this line are left of the clipping
rectangle, as indicated by the 1 in the first bit position of each region code.
A method that can be used to test lines for total clipping is to perform the logical
and operation with both region codes. If the result is not 0000,the line is completely
outside the clipping region.
Line extending from one coordinates region to another may pass through the clip
window, or they may intersect clipping boundaries without entering window.
Cohen-Sutherland line clipping starting with bottom endpoint left, right , bottom
and top boundaries in turn and find that this point is below the clipping rectangle.
Starting with the bottom endpoint of the line from P1 to P2, we check P1 against
the left, right, and bottom boundaries in turn and find that this point is below the clipping
rectangle. We then find the intersection point P1’ with the bottom boundary and discard
the line section from P1 to P1’.
The line now has been reduced to the section from P1’ to P2,Since P2, is outside the
clip window, we check this endpoint against the boundaries and find that it is to the left
65
CS2401 –Computer Graphics Unit - I
of the window. Intersection point P2’ is calculated, but this point is above the window. So
the final intersection calculation yields P2”, and the line from P1’ to P2”is saved. This
completes processing for this line, so we save this part and go on to the next line.
Point P3 in the next line is to the left of the clipping rectangle, so we determine the
intersection P3’, and eliminate the line section from P3 to P3'. By checking region codes
for the line section from P3'to P4 we find that the remainder of the line is below the clip
window and can be discarded also.
Intersection points with a clipping boundary can be calculated using the slope-
intercept form of the line equation. For a line with endpoint coordinates (x1,y1) and (x2,y2)
and the y coordinate of the intersection point with a vertical boundary can be obtained
with the calculation.
y =y1 +m (x-x1)
where x value is set either to xwmin or to xwmax and slope of line is calculated as
x= x1 +( y- y1) / m
66
CS2401 –Computer Graphics Unit - I
67
CS2401 –Computer Graphics Unit - I
if(INSIDE(code1))
{
swappts(&p1,&p2);
swapcodes(&code1,&code2);
}
if(p2.x!=p1.x)
m=(p2.y-p1.y)/(p2.x-p1.x);
if(code1 &LEFT_EDGE)
{
p1.y+=(winmin.x-p1.x)*m;
p1.x=winmin.x;
}
else if(code1 &RIGHT_EDGE)
{
p1.y+=(winmax.x-p1.x)*m;
p1.x=winmax.x;
}
else if(code1 &BOTTOM_EDGE)
{
if(p2.x!=p1.x)
p1.x+=(winmin.y-p1.y)/m;
p1.y=winmin.y;
}
else if(code1 &TOP_EDGE)
{
if(p2.x!=p1.x)
p1.x+=(winmax.y-p1.y)/m;
p1.y=winmax.y;
}
}
}
if(draw)
lineDDA(ROUND(p1.x),ROUND(p1.y),ROUND(p2.x),ROUND(p2.y));
}
x = x1 + u ∆x
y = y1 + u ∆y 0<=u<=1
68
CS2401 –Computer Graphics Unit - I
p1 = -∆x q1 = x1 - xwmin
p2 = ∆x q2 = xwmax - x1
P3 = -∆y q3 = y1- ywmin
P4 = ∆y q4 = ywmax - y1
Any line that is parallel to one of the clipping boundaries have pk=0 for values of
k corresponding to boundary k=1,2,3,4 correspond to left, right, bottom and top
boundaries. For values of k, find qk<0, the line is completely out side the boundary.
When pk<0 the infinite extension of line proceeds from outside to inside of the
infinite extension of this clipping boundary.
If pk>0, the line proceeds from inside to outside, for non zero value of pk calculate
the value of u, that corresponds to the point where the infinitely extended line intersect
the extension of boundary k as
u = qk / pk
For each line, calculate values for parameters u1and u2 that define the part of line
that lies within the clip rectangle. The value of u1 is determined by looking at the
rectangle edges for which the line proceeds from outside to the inside (p<0).
rk = qk / pk
69
CS2401 –Computer Graphics Unit - I
The value of u1 is taken as largest of set consisting of 0 and various values of r. The
value of u2 is determined by examining the boundaries for which lines proceeds from
inside to outside (P>0).
A value of rkis calculated for each of these boundaries and value of u2 is the
minimum of the set consisting of 1 and the calculated r values.
If u1>u2, the line is completely outside the clip window and it can be rejected.
Line intersection parameters are initialized to values u1=0 and u2=1. for each
clipping boundary, the appropriate values for P and q are calculated and used by function
Cliptest to determine whether the line can be rejected or whether the intersection
parameter can be adjusted.
If updating u1 or u2 results in u1>u2 reject the line, when p=0 and q<0, discard the line,
it is parallel to and outside the boundary.If the line has not been rejected after all four
value of p and q have been tested , the end points of clipped lines are determined from
values of u1 and u2.
The Liang-Barsky algorithm is more efficient than the Cohen-Sutherland
algorithm since intersections calculations are reduced. Each update of parameters u1 and
u2 require only one division and window intersections of these lines are computed only
once.
Cohen-Sutherland algorithm, can repeatedly calculate intersections along a line
path, even through line may be completely outside the clip window. Each intersection
calculations require both a division and a multiplication.
70
CS2401 –Computer Graphics Unit - I
r=q/p
if (r>*u2)
retVal=FALSE;
else
if (r>*u1)
*u1=r;
}
else
if (p>0.0)
{
r=q/p
if (r<*u1)
retVal=FALSE;
else
if (r<*u2)
*u2=r;
}
else
if )q<0.0)
retVal=FALSE
return(retVal);
void clipLine (dcPt winMin, dcPt winMax, wcPt2 p1, wcpt2 p2)
{
float u1=0.0, u2=1.0, dx=p2.x-p1.x,dy;
if (clipTest (-dx, p1.x-winMin.x, &u1, &u2))
if (clipTest (dx, winMax.x-p1.x, &u1, &u2))
{
dy=p2.y-p1.y;
if (clipTest (-dy, p1.y-winMin.y, &u1, &u2))
if (clipTest (dy, winMax.y-p1.y, &u1, &u2))
{
if (u1<1.0)
{
p2.x=p1.x+u2*dx;
p2.y=p1.y+u2*dy;
}
if (u1>0.0)
{
p1.x=p1.x+u1*dx;
p1.y=p1.y+u1*dy;
}
lineDDA(ROUND(p1.x),ROUND(p1.y),ROUND(p2.x),ROUND(p2.y));
71
CS2401 –Computer Graphics Unit - I
}
}
}
For a line with endpoints P1 and P2 we first determine the position of point P1,
for the nine possible regions relative to the clipping rectangle. Only the three regions
shown in Fig. need to be considered. If P1 lies in any one of the other six regions, we can
move it to one of the three regions in Fig. using a symmetry transformation. For
example, the region directly above the clip window can be transformed to the region left
of the clip window using a reflection about the line y = -x, or we could use a 90 degree
counterclockwise rotation.
Three possible positions for a line endpoint p1(a) in the NLN algorithm
72
CS2401 –Computer Graphics Unit - I
Next, we determine the position of P2 relative to P1. To do this, we create some new
regions in the plane, depending on the location of P1. Boundaries of the new regions are
half-infinite line segments that start at the position of P1 and pass through the window
corners. If P1 is inside the clip window and P2 is outside, we set up the four regions
shown in Fig
The four clipping regions used in NLN alg when p1 is inside and p2 outside the clip
window
The intersection with the appropriate window boundary is then carried out,
depending on which one of the four regions (L, T, R, or B) contains P2. If both P1 and P2
are inside the clipping rectangle, we simply save the entire line.
If P1 is in the region to the left of the window, we set up the four regions, L, LT, LR, and
LB, shown in Fig.
73
CS2401 –Computer Graphics Unit - I
These four regions determine a unique boundary for the line segment. For instance, if P2
is in region L, we clip the line at the left boundary and save the line segment from this
intersection point to P2. But if P2 is in region LT, we save the line segment from the left
window boundary to the top boundary. If P2 is not in any of the four regions, L, LT, LR,
or LB, the entire line is clipped.
For the third case, when P1 is to the left and above the clip window, we usethe clipping
regions in Fig.
Fig : The two possible sets of clipping regions used in NLN algorithm when P1 is
above and to the left of the clip window
In this case, we have the two possibilities shown, depending on the position of P1,
relative to the top left corner of the window. If P2, is in one of the regions T, L, TR, TB,
LR, or LB, this determines a unique clip window edge for the intersection calculations.
Otherwise, the entire line is rejected.
74
CS2401 –Computer Graphics Unit - I
line to the slopes of the boundaries of the clip regions. For example, if P1 is left of
slopeP1PTR<slopeP1P2<slopeP1PTL
or
yT – y1 < y2 – y1 < yT – y1
xR – x1 x2 – x1 xL – x1
The coordinate difference and product calculations used in the slope tests are
saved and also used in the intersection calculations. From the parametric equations
x = x1 + (x2 – x1)u
y = y1 + (y2 – y1)u
y = y1 + y2 – y1 (xL – x1 )
x2 – x1
And an intersection position on the top boundary has y = yT and u = (yT – y1)/ (y2 – y1)
with
x = x1 + x2 – x1 (yT – y1 )
y2 – y1
POLYGON CLIPPING
75
CS2401 –Computer Graphics Unit - I
For polygon clipping, we require an algorithm that will generate one or more closed areas
that are then scan converted for the appropriate area fill. The output of a polygon clipper
should be a sequence of vertices that defines the clipped polygon boundaries.
There are four possible cases when processing vertices in sequence around the
perimeter of a polygon. As each point of adjacent polygon vertices is passed to a window
boundary clipper, make the following tests:
1. If the first vertex is outside the window boundary and second vertex is inside,
both the intersection point of the polygon edge with window boundary and
second vertex are added to output vertex list.
2. If both input vertices are inside the window boundary, only the second vertex
is added to the output vertex list.
76
CS2401 –Computer Graphics Unit - I
3. If first vertex is inside the window boundary and second vertex is outside only
the edge intersection with window boundary is added to output vertex list.
4. If both input vertices are outside the window boundary nothing is added to the
output list.
Clipping a polygon against successive window boundaries.
Successive processing of pairs of polygon vertices against the left window boundary
Clipping a polygon against the left boundary of a window, starting with vertex 1.
Primed numbers are used to label the points in the output vertex list for this window
boundary.
77
CS2401 –Computer Graphics Unit - I
vertices 1 and 2 are found to be on outside of boundary. Moving along vertex 3 which is
inside, calculate the intersection and save both the intersection point and vertex 3. Vertex
4 and 5 are determined to be inside and are saved. Vertex 6 is outside so we find and save
the intersection point. Using the five saved points we repeat the process for next window
boundary.
Implementing the algorithm as described requires setting up storage for an output list of
vertices as a polygon clipped against each window boundary. We eliminate the
intermediate output vertex lists by simply by clipping individual vertices at each step and
passing the clipped vertices on to the next boundary clipper.
A point is added to the output vertex list only after it has been determined to be inside or
on a window boundary by all boundary clippers. Otherwise the point does not continue in
the pipeline.
Processing the vertices of the polygon in the above fig. through a boundary clipping
pipeline. After all vertices are processed through the pipeline, the vertex list is {
v2”, v2’, v3,v3’}
78
CS2401 –Computer Graphics Unit - I
79
CS2401 –Computer Graphics Unit - I
ipt.y=p2.y+(wmin.x-p2.x)*m;
break;
case Right:
ipt.x=wmax.x;
ipt.y=p2.y+(wmax.x-p2.x)*m;
break;
case Bottom:
ipt.y=wmin.y;
if(p1.x!=p2.x)
ipt.x=p2.x+(wmin.y-p2.y)/m;
else
ipt.x=p2.x;
break;
case Top:
ipt.y=wmax.y;
if(p1.x!=p2.x)
ipt.x=p2.x+(wmax.y-p2.y)/m;
else
ipt.x=p2.x;
break;
}
return(ipt);
}
void clippoint(wcPt2 p,Edge b,dcPt wmin,dcPt wmax, wcPt2 *pout,int *cnt, wcPt2
*first[],struct point *s)
{
wcPt2 iPt;
if(!first[b])
first[b]=&p;
else
if(cross(p,s[b],b,wmin,wmax))
{
ipt=intersect(p,s[b],b,wmin,wmax);
if(b<top)
clippoint(ipt,b+1,wmin,wmax,pout,cnt,first,s);
else
{
pout[*cnt]=ipt;
(*cnt)++;
}
}
s[b]=p;
if(inside(p,b,wmin,wmax))
80
CS2401 –Computer Graphics Unit - I
if(b<top)
clippoint(p,b+1,wmin,wmax,pout,cnt,first,s);
else
{
pout[*cnt]=p;
(*cnt)++;
}
}
void closeclip(dcPt wmin,dcPt wmax, wcPt2 *pout,int *cnt,wcPt2 *first[], wcPt2 *s)
{
wcPt2 iPt;
Edge b;
for(b=left;b<=top;b++)
{
if(cross(s[b],*first[b],b,wmin,wmax))
{
i=intersect(s[b],*first[b],b,wmin,wmax);
if(b<top)
clippoint(i,b+1,wmin,wmax,pout,cnt,first,s);
else
{
pout[*cnt]=i;
(*cnt)++;
}
}
}
}
int clippolygon(dcPt point wmin,dcPt wmax,int n,wcPt2 *pin, wcPt2 *pout)
{
wcPt2 *first[N_EDGE]={0,0,0,0},s[N_EDGE];
int i,cnt=0;
for(i=0;i<n;i++)
clippoint(pin[i],left,wmin,wmax,pout,&cnt,first,s);
closeclip(wmin,wmax,pout,&cnt,first,s);
return(cnt);
}
81
CS2401 –Computer Graphics Unit - I
The basic idea in this algorithm is that instead of always proceeding around the
polygon edges as vertices are processed, we sometimes want to follow the window
boundaries. Which path we follow depends on the polygon-processing direction
(clockwise or counterclockwise) and whether the pair of polygon vertices currently being
processed represents an outside-to-inside pair or an inside- to-outside pair. For clockwise
processing of polygon vertices, we use the following rules:
For an outside-to-inside pair of vertices, follow the polygon boundary.
For an inside-to-outside pair of vertices,. follow the window boundary in a
clockwise direction.
In the below Fig. the processing direction in the Weiler-Atherton algorithm and the
resulting clipped polygon is shown for a rectangular clipping window.
Curve Clipping
But if the bounding rectangle test fails, we can look for other computation-saving
approaches. For a circle, we can use the coordinate extents of individual quadrants and
then octants for preliminary testing before calculating curve-window intersections.
The below figure illustrates circle clipping against a rectangular window. On the
first pass, we can clip the bounding rectangle of the object against the bounding rectangle
82
CS2401 –Computer Graphics Unit - I
of the clip region. If the two regions overlap, we will need to solve the simultaneous line-
curve equations to obtain the clipping intersection points.
Text clipping
There are several techniques that can be used to provide text clipping in a graphics
package. The clipping technique used will depend on the methods used to
generate characters and the requirements of a particular application.
83
CS2401 –Computer Graphics Unit - I
A final method for handling text clipping is to clip the components of individual
characters. We now treat characters in much the same way that we treated lines. If an
individual character overlaps a clip window boundary, we clip off the parts of the
character that are outside the window.
Exterior clipping:
Objects within a window are clipped to interior of window when other higher
priority window overlap these objects. The objects are also clipped to the exterior of
overlapping windows.
84