An algorithm for Line Drawing Using Parametric Equation.pdf

Embed Size (px)

Citation preview

  • 8/20/2019 An algorithm for Line Drawing Using Parametric Equation.pdf

    1/8

    International Journal of Computer Graphics

    Vol. 2 No. 1 May 2011

    9

    An algorithm for Line Drawing Using Parametric Equation

    Kumar S. Ray

     Electronics & Communication Sciences Unit Indian Statistical Institute 203, B.T. Road, Kolkata –  700108, India

    Bimal Kumar Ray

    School of Information Technology & Engineering

    VIT University, Vellore –  632 014, India

    Abstract

    This paper presents two algorithms for drawing line using the parametric equations ofline segment. The first algorithm uses floating-point arithmetic and the second uses integer

    arithmetic. The method of derivation of the algorithms presented here is borrowed from that

     presented in Vector generation algorithm and the Bresenham’s algorithm. But both thesealgorithms consider the slope-intercept form of line segment. Hence, in both the cases, the

    line segments with sharp slope and those with gentle slope are to be considered separately. But the proposed algorithms do not require the same. Thus the proposed algorithms reduce

    the number of lines of code and computationally become more efficient.

    Keywords Parametric equation, digitization, digital line

    1. Introduction

    Digital line generation is a fundamental tool of computer graphics. One needs an efficientalgorithm for generation of digital line segment especially for animated display. In absence of

    efficient algorithm the animated display will deviate from realistic view. A number ofalgorithms are already  published in this area. The most famous of these is the Bresenham’salgorithm that can be found in [1] and [2]. In [3] Danielsson presented an incremental methodfor curve generation using parametric equations. It not only deals with lines but also withother curves. In the same paper, Danielsson also talked about curve generation using non-

     parametric equation. In [4] Pittway and Watkinson addressed the problem of line generation

    with gray scale. This results in pleasing visual effect with display devices that permit multiplelevels of intensities. In [5] Dan Field presented two incremental linear interpolation

    algorithms and analyzed their speed and accuracy. The first of these algorithms is a simpledigital differential algorithm employing fixed-point arithmetic and the second one is a newalgorithm which makes use of integer arithmetic and is a generalization of the Bresenham’s

    line drawing algorithm. The algorithm is accurate and faster than the fixed-point algorithm

    depending upon the underlying processor. The other algorithms for digital line generation can be found in [6] through [10].

    This paper presents two algorithms for digital line generation using the parametricequations of line segment. The first algorithm uses floating-point arithmetic and the second

    uses integer arithmetic only. The method of derivation of the algorithms presented here is borrowed from that presented in Vector generation algorithm and the Bresenham’s algorithm

    [2]. But both these algorithms consider the slope-intercept form of line segment. In both thecases the line segments with sharp slope and those with gentle slope are to be considered

  • 8/20/2019 An algorithm for Line Drawing Using Parametric Equation.pdf

    2/8

    International Journal of Computer Graphics

    Vol. 2 No. 1 May 2011

    10

    separately. But the proposed algorithms do not require the same. Hence the proposedalgorithm reduce the number of lines of code and computationally become more efficient. Insection 2 a trivial approach is presented which can be found in any textbook, in section 3 animprovement over the trivial approach is shown. The algorithm presented in section 3involves floating point arithmetic. In section 4 it is shown how the algorithm presented in

    section 3 can be modified so as to produce an algorithm that uses integer arithmetic only.

    2. A Trivial Approach

    The parametric equations of a line segment with the end points ( x1, y1) and ( x2, y2) are

    with 0  u  1. The length of the line segment is L = [( x2  –   x1)2 + ( y2  –   y1)

    2]

    1/2and the slope of

    the line segment is m = ( y2  –   y1) / ( x2  –   x1). We propose to write dx = x2  –   x1 and dy = y2  –   y1.One can derive a simple algorithm for line generation using the iterative formulae  x = x +

    dx*du  and  y = y + dy*du  which can be obtained by taking differentials of the parametric

    equations of the line segment. The step size of u (the value of du) can be computed using du =1/ L. Instead of using the conventional expression for the length of line segment, in this paperwe approximate L as L = |dx| + |dy|. This approximation of  L will speed up the computationand had also been found to reduce the jaggies (aliasing) from the line segment. This method

    computes the full value of x and y and has been found to result in overdraw of pixels.

    3. An Improvement

    In order to avoid computation of the full value of  x and  y  we introduce two variables,namely d  and h. The variable d  will measure the horizontal distance of the mathematical linesegment from the nearest pixel center. The variable h will measure the vertical distance of the

    mathematical line segment from the nearest pixel center. Without loss of generality it can be

    assumed that the slope is positive and dx > 0. The first pixel along the digital line segment isassumed to be ( xa, ya). To determine the next pixel, we compute the vertical distance (h) ofthe mathematical line segment using h = dx*du measured from the centerline of the pixel ( xa,

     ya). We also compute the horizontal distance (d ) of the mathematical line segment from the

    centerline of the pixel ( xa, ya) using d . Compare each of h and d  with 0.5. As long as d  is lessthan 0.5 keep incrementing d   by the amount dx*du. When d   is no longer less than 0.5increment the x coordinate of the last pixel by 1. Also adjust the d  value by adding dx*du to d  

    and subtracting 1 from the same. The decision parameter h and the ordinate  y may be dealtwith in the same manner. The updated value of  x and y are calculated in this way so that for a

    new pixel position the h and d  value are measured from the centerline of the new pixel. Bythis process computation of the full value of h  and d   is avoided. The C source code forgenerating the line segment is presented below. We have used a system dependent routine

    namely, putpixel( x,  y, intensity) to turn on the pixel ( x,  y) with the intensity value intensity.The Figure 1 through Figure5 displays the output of this algorithm for different pair of end

     points.

    void VectorGeneration (float xa, float ya, float xb, float yb, int intensity){

    float du, dx, dy, u, x, y, L, h, d , hx, hy, xstart , ystart , xend , yend ;int flag ;

    u y y y x

    u x x x x

    )(

    )(

    121

    121

  • 8/20/2019 An algorithm for Line Drawing Using Parametric Equation.pdf

    3/8

    International Journal of Computer Graphics

    Vol. 2 No. 1 May 2011

    11

    u = 0;dx = xb –  xa;dy = yb –  ya;

     L = fabs(dx) +fabs(dy);

    du = 1/ L;h = hx = fabs(dx) *du;d  = hy = fabs(dy) *du;if ( dx > 0 ) {

     xstart  = xa; xend  =  xb;

    }else {

     xstart  = xb; xend =  xa;

    }

    if ( dy > 0 ) {

     ystart  = ya; yend  =  yb;}else {

     ystart  = yb; yend =  ya;

    } flag  = (dx > 0);if (dy < 0) flag = !flag;

    if ( flag ) { // positive slope x = xstart ;

     y = ystart ;while ( x = 0.5 ) {

     y = y + 1;d  = d  + hy  – 1;

    }}

    else { // negative slope x = xstart ; y = yend ;while( x = ystart ) {

     putpixel(int( x + 0.5), int( y + 0.5), intensity);

    if (h < 0.5) h = h + hx;

  • 8/20/2019 An algorithm for Line Drawing Using Parametric Equation.pdf

    4/8

    International Journal of Computer Graphics

    Vol. 2 No. 1 May 2011

    12

    if ( h >= 0.5 ) { x  = x + 1;h  = h + hx -1;

    }if (d  < 0.5)

    d  = d  + hy;if (d   >= 0.5) { y  = y - 1;d   = d  + hy - 1;

    }

    }// end of while}// end of negative slope

    return;

    }//end of routine

    4. Integer Arithmetic Algorithm

    The last algorithm is now converted into the one that involves integer arithmetic only. Asearlier it is assumed that the slope is gentle and positive and the first pixel on the line segment

    is ( xa, ya) and the last pixel is ( xb, yb). The test performed in the last algorithm was if h  0.5

    and this implies that 2h  –  1  0. But as du is a floating-point number computed by du = 1/ L so

    also h. So we multiply both sides of the test expression 2h  –  1  0 by L = |dx| + |dy| and we

    get 2hL  –   L  0. We introduce g  = 2hL  –   L. So h = ( g  + L)/2 L. If hn and ho respectively denotethe old and the new value of h then hn = ho + hx which gives ( g n + L)/2 L = ( g o + L)/2 L + dxdu,

    which in turn reduces to gn = go + 2dx because Ldu = 1. So the test h < 0.5 reduces to if g  < 0and if the condition is true then g  = g  + 2dx. Again if h >= 0.5 then the new value of h should

     be computed by the formula hn = ho + hx  1 which gives ( g n + L)/2 L = ( g o + L)/2 L + dxdu  

    1, which in turn reduces to gn = go + 2dx  –  2 L. So the test if h  0 reduces to if g   0 and if thecondition is satisfied then g should be updated by the formula  g   =  g   + 2(dx  –   L). Similar

    arguments will lead to the corresponding test condition for d   and the updating formulae,namely, if  g   0 then  g  =  g  + 2dy  and if  g    0 then  g  =  g  + 2(dy  –   L). If we take intoaccount lines of all kinds of slopes then in the above test we have to replace dx and dy by their

    absolute values. The C source code for the algorithm is given below. In the source code, the

    symbols g and g have been replaced by h and d   respectively and the increments in h and d  have been denoted by h1, h2 and d 1, and d 2 so as to maintain similarity with the last source

    code. The Figure 1 through Figure5 displays the output of this algorithm for different pair ofend points.

    void LineGeneration ( int xa, int ya, int xb, int yb, intensity){

    int x, y, L;

    int xa, ya, xb, yb, dx, dy, h, h1, h2, d , d 1, d 2, xstart , ystart , xend , yend , flag ;dx = xb - xa;dy = yb - ya;

     L = abs(dx) + abs(dy);

    h = 2*abs(dx) - L;d  = 2*abs(dy) - L;

    h1 = 2*abs(dx); h2 = 2*(abs(dx) –  L);d 1 = 2*abs(dy); d 2 = 2*(abs(dy) –  L);

  • 8/20/2019 An algorithm for Line Drawing Using Parametric Equation.pdf

    5/8

    International Journal of Computer Graphics

    Vol. 2 No. 1 May 2011

    13

    if (dx > 0) { xstart  = xa; xend =  xb;

    }

    else {  xstart  = xb; xend   = xa;

    }

    if (dy >0) { ystart  = ya;

     yend = yb;}else {

     ystart  = yb; yend  = ya;

    }

     flag  = (dx > 0);if (dy < 0) flag  = ! flag ;if ( flag ) {

     x = xstart ;

     y = ystart ;while( x = 0) {

     y  = y + 1;d   = d  + d 2;

    }}//while

    } //if (flag)

    else { // negative slope x = xstart ;

     y = yend ;while( x =ystart ) {

     putpixel( x, y, intensity);if (h < 0) h = h + h1;if (h >= 0) {

     x  = x + 1;h  = h + h2;

    }if (d  < 0) d  = d  + d 1;if (d  >= 0) {

     y = y − 1;

  • 8/20/2019 An algorithm for Line Drawing Using Parametric Equation.pdf

    6/8

    International Journal of Computer Graphics

    Vol. 2 No. 1 May 2011

    14

    d   = d  + d 2;}}//end of while

    }// end of else}//end of routine

    5. Conclusion

    An alternative method of drawing line segment has been proposed using the parametricequations. Two algorithms, one floating-point and the other integer-arithmetic, have been

    derived for drawing lines. In contrast to the Bresenham’s algorithm, the proposed methoddoes not need to consider the lines with gentle slope and those with sharp slope separately.

    Thus, the present algorithm is shorter than the Bresenham’s algorithm. The present algorithmrequires five additional variables which is an extra cost required over the Bresenham’salgorithm.

    References

    [1] Bresenham J. E., “Algorithm for Computer Control of a Digital Plotter”, IBM System Journal, vol.4,  no. 1, pp. 106 – 111, 1965.

    [2] Steven Harrington, “Computer Graphics - A Programming Approach”, McGraw-Hill International Editions,2nd Ed., 1987.

    [3] P. E. Danielsson, “Incremental Curve Generation”, IEEE Transactions on Computers, vol. C-19, pp.763-793,1970.

    [4] Pittway M.L.V. and Watkinson D.J., “Bresenham’s algorithm with gray scale”, Communications of theACM, vol.23, pp.625-626, 1980.

    [5] Field D. “Incremental Linear Interpolation”, ACM Transactions on Graphics, vol.4, pp.1-11, 1985.

    [6] Loceff M., A new approach to high-speed computer graphics: The line”, vol.13, pp.56-66, 1980.

    [7] Sproull R.F., “Using program transformations to derive line-drawing algorithms”, ACM Transactions onGraphics, vol.1, pp.259-273, 1982.

    [8] Tran-Thong, “A symmetric linear algorithm for line segment generation”, Computer and Graphics, vol.6,

     pp15-17, 1982.[9] Kaufman A., “Efficient algorithm for 3-D scan-conversion of parametric curves, surfaces and volumes”, in

     proceedings of SIGGRAPH ’82, Computer Graphics, vol. 16, p p. 223-232, 1982.

    [10] Earnshaw R.A., “Line generation for incremental and raster devices”, Computer Graphics, vol. 11, pp. 199 -205, 1977. 

    (a) (b) (c)

    Figure 1. Line Segment with End Points (3,5) and (12, 22):(a) VectorGeneration; (b) LineGeneration; (c) Bresenham’s Algorithm 

  • 8/20/2019 An algorithm for Line Drawing Using Parametric Equation.pdf

    7/8

    International Journal of Computer Graphics

    Vol. 2 No. 1 May 2011

    15

    (a) (b) (c)

    Figure 2. Line Segment with End Points (15, 5) and (18, 22):(a) VectorGeneration; (b) LineGeneration; (c) BresenHam’s Algorithm 

    (a) (b) (c)

    Figure 3. Line Segment with End Points (15, 29) and (5, 19):(a) VectorGeneration; (b) LineGeneration; (c) Bresenham’s Algorithm 

  • 8/20/2019 An algorithm for Line Drawing Using Parametric Equation.pdf

    8/8

    International Journal of Computer Graphics

    Vol. 2 No. 1 May 2011

    16