1. DDA Algorithm(Digital Differential Analyzer)

Transcription

1 Basic concepts in line drawing: We say these computers have vector graphics capability (the line is a vector). The process is turning on pixels for a line segment is called vector generation and algorithm for them is known as vector generation algorithm. Problems of vector generation: Line is straight but width is no constant. Brightness of line dependent on orientation of the line. Calculate only an approximate line length. Reduce the calculations using simple integer arithmetic. Line Drawing Algorithms 1. DDA Algorithm(Digital Differential Analyzer) DDA algorithm is an incremental scan conversion method. Here we perform calculations at each step using the results from the preceding step. Digital Differential Analyzer (DDA) algorithm is the simple line generation algorithm which is explained step by step here. Procedure for DDA Algorithm: 1. Read line end points(x1,y1) and (x2,y2) such that they are not equal. 2. dy= y2-y1 and dx= x2-x1 3. If ( dx > dy) then Length=dx Else Length=dy 4. dx=(x2-x1)/length dy=(y2-y1)/ Length 5. x=x1+0.5*sign(dx) y=y1+0.5*sign(dy) 6. i=1 while (i< Length) Plot (Integer(x), Integer(y)) X=x+dx Y=y+dy

2 7. i=i+1 8.Stop Program: #include<stdio.h> #include<conio.h> #include<graphics.h> void main() int x1,y1,x2,y2,dx,dy,length,i; float x,y,xinc,yinc; int gd=detect,gm; initgraph(&gd,&gm,"c:\\turboc3\\bgi"); printf("enter the starting coordinates"); scanf("%d%d",&x1,&y1); printf("enter the ending coordinates"); scanf("%d%d",&x2,&y2); dx=x2-x1; dy=y2-y1; if(abs(dx)>abs(dy)) length=abs(dx); else length=abs(dy); xinc=dx/(float)length;

3 yinc=dy/(float)length; x=x1 y=y1 putpixel(x,y,10); for(i=0;i<length;i++) putpixel(x,y,10); x=x+xinc; y=y+yinc; delay(10); getch(); closegraph(); Advantages of DDA Algorithm 1. It is the simplest algorithm and it does not require special skills for implementation. 2. It is a faster method for calculating pixel positions. Disadvantages of DDA Algorithm 1. Floating point arithmetic in DDA algorithm is still time-consuming. 2. The algorithm is orientation dependent. Hence end point accuracy is poor. Example Consider the line from (0, 0) to (-6, -6). Use the simple DDA algorithm line. Sol. Evaluating steps 1 to 5 in the DDA algorithm we have Xl = 0 Y1 = 0 X2 = - 6 Y2 = - 6 Length = l X2-X1l Y2-Y1l = 6

4 X = Y = -1 Initial values for X = * Sign (-1) =-0.5 Y = * Sign (-1) =-0.5 Tabulating the results of each iteration in the step 6 we get, 2. Bresenham's Algorithm. It s an accurate and efficient raster line generating Algorithm. Bresenham's line-drawing algorithm uses an iterative scheme. A key feature of the algorithm is that it requires only integer data and simple arithmetic. This makes the algorithm very efficient and fast. Procedure for Bresenham s algorithm: 1.Read line end points (x1,y1) and (x2,y2) such that they are not equal. 2. dx= x2-x1 and dy= y2-y1 3.x=x1 and y=y1 4.e=2*dy-dx 5.i=1

5 6.plot (x,y) 7.while (e>0) x=y+1 e=e-2*dx x=x+1 e=e+2*dy 8.i=i+1 9.if(i<dx) then goto step Stop. Program- Bresenham Line Drawing Algorithm -: #include<stdio.h> #include<conio.h> #include<graphics.h> #include<math.h> void main() int gd=detect,gm=detect,length,dx,dy,x1,y1,x2,y2,e; float x,y; clrscr(); printf("\n enter coordinates of x1,y1,x2,y2"); scanf("%d%d%d%d",&x1,&y1,&x2,&y2); dx=x2-x1; dy=y2-y1; e=2*(dy-dx); x=x1; y=y1; initgraph(&gd,&gm,"c://turboc3//bgi"); while(x<=x2) if(e<0)

6 x=x+1; y=y; e=e+2*dy; else x=x+1; y=y+1; e=e+2*(dy-dx); putpixel(x,y,15); getch(); closegraph(); Problem: - Consider the line from (5, 5) to (13, 9). Use the Bresenham's algorithm to rasterize the line. Solution :- Evaluating steps 1 through 4 in the Bresenham s algorithm we have, Given: - step 1 :- x1 = 5, y1 = 5 and x2 = 13, y2 = 9. step 2 :- Δx = 13-5 =8 Δy = 9-5 = 4 step 3 :- x = 5, y = 5 step 4 :- e = 2 * Δy - Δx = 2 * 4-8 = 0. Tabulating the results of each iteration in the step 5 through 10.

7 DDA Line Drawing Algorithm vs Bresenhams Line Drawing Algorithm Arithmetic uses floating points Integer points Operations Uses multiplication and division in its operations. Uses only subtraction and addition in its operations. Speed slowly than Bresenhams algorithm faster than DDA Accuracy & Efficiency Drawing not as accurate and efficient DDA algorithm can draw circles and curves but that are not as accurate as Bresenhams algorithm. more efficient &much accurate Draw circles and curves with much more accuracy than DDA algorithm. Round Off DDA algorithm round off the coordinates to Bresenhams algorithm does not round off but takes the

8 integer that is nearest to the line. incremental value in its operation. Expensive expensive. less expensive Circle generating algorithm: Symmetry of circle: A circle is a geometric figure which is round, and can be divided into 360 degrees. A circle is a symmetrical figure which follows 8-way symmetry. 8-Way symmetry: Any circle follows 8-way symmetry. This means that for every point (x,y) 8 points can be plotted. These (x,y), (y,x), (-y,x), (-x,y), (-x,-y), (-y,-x), (y,-x), (x,-y). Drawing a circle: To draw a circle we need two things, the coordinates of the centre and the radius of the circle. Here r is the radius of the circle. If the circle has origin (0,0) as its centre then the above equation can be reduced to x2 + y2 = r2 Bresenham s Algorithm We cannot display a continuous arc on the raster display. Instead, we have to choose the nearest pixel position to complete the arc. From the following illustration, you can see that we have put the pixel at (X, Y) location and now need to decide where to put the next pixel at N (X+1, Y) or at S (X+1, Y-1).

9 This can be decided by the decision parameter d. If d <= 0, then N(X+1, Y) is to be chosen as next pixel. If d > 0, then S(X+1, Y-1) is to be chosen as the next pixel. Breshenham s Algorithm For Circle Drawing 1. Read the radius of circle. 2. Calculate initial decision parameter di=3-2r 3. x=0 and y=r [initialize the starting point] 4. Do 5. Plot(x,y)//plot point(x,y) and other 7 points in all octant if(di<0)then di=di+4x=6 else di=di+4(x-y)+10 y=y-1 x=x+1 while(x<y); 6. stop

10 Program : bresenhams circle drawing algorihm #include<stdio.h> #include<conio.h> #include<math.h> #include<dos.h> #include<graphics.h> void bressn(int,int,int); void plot(int,int,int,int); void plot(int xc,int yc,int x,int y) putpixel(xc+x,yc+y,white); putpixel(xc-x,yc+y,red); putpixel(xc-x,yc-y,green); putpixel(xc+x,yc-y,yellow); putpixel(xc+y,yc+x,white); putpixel(xc-y,yc+x,green); putpixel(xc-y,yc-x,yellow); putpixel(xc+y,yc-x,red); void bressn(int r,int xc,int yc) int d,x,y; d=3-(2*r); x=0; y=r;

11 while(x<y) plot(xc,yc,x,y); x=x+1; if(d<0) d=d+(4*x)+6; else y=y-1; d=d+4*(x-y)+10; plot(xc,yc,x,y); void main() int gd,gm; int xc,yc,radius; detectgraph(&gd,&gm); initgraph(&gd,&gm,"c:\\turboc3\\bgi"); printf("\n enter xc,yc,radius"); scanf("%d%d%d",&xc,&yc,&radius); bressn(xc,yc,radius);

12 Example : getch(); closegraph(); Calculate the pixel position along the circle path with radius r=10 centered on the origin using Bresenham s circle drawing algorithm from point (0,10) to point x=y. Solution: The value of d is d=3-2r=3-2*10=-17 Tabulating results of step 4 Polygon: x y d A polygon is any 2-dimensional shape formed with straight lines. Triangles, quadrilaterals, pentagons, and hexagons are all examples of polygons. Types of polygon: Every polygon is either convex or concave. The difference between convex and concave polygons lies in the measures of their angles. For a polygon to be convex, all of its interior angles must be less than 180 degrees. Otherwise, the polygon is concave.

13 Inside-Outside Test This method is also known as counting number method. While filling an object, we often need to identify whether particular point is inside the object or outside it. There are two methods by which we can identify whether particular point is inside an object or outside. Odd-Even Rule Nonzero winding number rule Odd-Even Rule In this technique, we will count the edge crossing along the line from any point (x,y) to infinity. If the number of interactions is odd, then the point (x,y) is an interior point; and if the number of interactions is even, then the point (x,y) is an exterior point. The following example depicts this concept.

14 From the above figure, we can see that from the point (x,y), the number of interactions point on the left side is 5 and on the right side is 3. From both ends, the number of interaction points is odd, so the point is considered within the object. Nonzero Winding Number Rule This method is also used with the simple polygons to test the given point is interior or not. Give the value 1 to all the edges which are going to upward direction and all other -1 as direction values. Check the edge direction values from which the scan line is passing and sum up them. If the total sum of this direction value is non-zero, then this point to be tested is an interior point, otherwise it is an exterior point. In the above figure, we sum up the direction values from which the scan line is passing then the total is = 1; which is non-zero. So the point is said to be an interior point. Polygon filling: Polygon filling algorithms are classified as: seed fill algorithm and scan line algorithm. One way to fill polygon is to start from given seed, point known to be inside the polygon and highlight outward from this point i.e. neighboring pixels until we encounter the boundary pixels. This approach is called seed fill. Seed fill algorithm further classified as flood fill and boundary fill algorithm. Algorithms the fill interior defined regions are flood fill algorithms; those that fill boundary defined regions are called boundary fill algorithm. Another approach to fill the polygon is to apply the inside test i.e. to check whether the pixels is inside the polygon or outside the polygon and then highlight pixels which lie inside the polygon. This approach is known as scan-line algorithm.

15 Flood Fill Algorithm Flood fill colors an entire area in an enclosed figure through interconnected pixels using a single color. It is an easy way to fill color in the graphics. One just takes the shape and starts flood fill. The algorithm works in a manner so as to give all the pixels inside the boundary the same color leaving the boundary and the pixels outside. Flood fill algorithm is used for filling the interior of a polygon. Used when an area defined with multiple color boundaries. Start at a point inside a region Replace a specified interior color (old color) with fill color Fill the 4 connected or 8 connected region until all interior points being replaced. 4 Connected Regions From a given pixel, the region that you can get to by a series of 4 way moves (north, south, east, west) void fillcolor(int x,int y,int old_color,int new_color) if(getpixel(x,y)==old_color) delay(5); putpixel(x,y,new_color); fillcolor(x+1,y,old_color,new_color); fillcolor(x-1,y,old_color,new_color); fillcolor(x,y+1,old_color,new_color); fillcolor(x,y-1,old_color,new_color);

16 Program: #include<stdio.h> #include<conio.h> #include<graphics.h> #include<dos.h> void fillcolor(int,int,int,int); void main() int gd,gm; detectgraph(&gd,&gm); initgraph(&gd,&gm,"c:\\turboc3\\bgi"); rectangle(50,50,100,100); fillcolor(55,55,0,11); getch(); closegraph(); void fillcolor(int x,int y,int old_color,int new_color) if(getpixel(x,y)==old_color) delay(5); putpixel(x,y,new_color); fillcolor(x+1,y,old_color,new_color); fillcolor(x-1,y,old_color,new_color); fillcolor(x,y+1,old_color,new_color); fillcolor(x,y-1,old_color,new_color); 8 Connected Regions From a given pixel, the region that you can get to by a series of 8-way moves (north, south, east, west, NE, NW, SE, SW) void fillcolor(int x,int y,int old_color,int new_color) if(getpixel(x,y)==old_color) delay(5); putpixel(x,y,new_color); fillcolor(x+1,y,old_color,new_color); fillcolor(x-1,y,old_color,new_color); fillcolor(x,y+1,old_color,new_color); fillcolor(x,y-1,old_color,new_color); fillcolor(x+1,y+1,old_color,new_color);

17 fillcolor(x+1,y-1,old_color,new_color); fillcolor(x-1,y-1,old_color,new_color); fillcolor(x-1,y+1,old_color,new_color); Program: #include<stdio.h> #include<conio.h> #include<graphics.h> #include<dos.h> void fillcolor(int,int,int,int); void main() int gd,gm; detectgraph(&gd,&gm); initgraph(&gd,&gm,"c:\\turboc3\\bgi"); rectangle(50,50,100,100); fillcolor(55,55,0,11); getch(); closegraph(); void fillcolor(int x,int y,int old_color,int new_color) if(getpixel(x,y)==old_color) delay(5); putpixel(x,y,new_color); fillcolor(x+1,y,old_color,new_color); fillcolor(x-1,y,old_color,new_color); fillcolor(x,y+1,old_color,new_color); fillcolor(x,y-1,old_color,new_color); fillcolor(x+1,y+1,old_color,new_color); fillcolor(x+1,y-1,old_color,new_color); fillcolor(x-1,y-1,old_color,new_color); fillcolor(x-1,y+1,old_color,new_color); ADVANTAGE Flood fill algorithm is simplest algorithm.

18 DISADVANTAGE Flood fill algorithm is slow. For large polygon flood fill algorithm is fail because it requires a large frame. Boundary Fill Algorithm Start at a point inside the figure and paint with a particular color. Filling continues until a boundary color is encountered. In boundary fill algorithm Recursive method is used to fill the whole boundary. Start at a point inside a region. Paint the interior outward toward the boundary. The boundary is specified in a single color. 4-connected boundary fill Algorithm:- boundary_fill(x, y, f_colour, b_colour) if(getpixel(x, y)! = b_colour && getpixel(x, y)! = f_colour) putpixel(x, y, f_colour); boundary_fill(x + 1, y, f_colour, b_colour); boundary_fill(x, y + 1, f_colour, b_colour); boundary_fill(x -1, y, f_colour, b_colour); boundary_fill(x, y 1, f_colour, b_colour); Program: #include<stdio.h> #include<conio.h> #include<graphics.h> #include<dos.h> void boundary_fill(int,int,int,int); void main() int gd,gm; detectgraph(&gd,&gm); initgraph(&gd,&gm,"c:\\turboc3\\bgi"); rectangle(50,50,100,100); boundary_fill(55,55,6,15); getch();

19 closegraph(); void boundary_fill(int x,int y,int fcolor,int bcolor) if((getpixel(x,y)!=bcolor)&&(getpixel(x,y)!=fcolor)) delay(5); putpixel(x,y,fcolor); boundary_fill(x+1,y,fcolor,bcolor); boundary_fill(x-1,y,fcolor,bcolor); boundary_fill(x,y+1,fcolor,bcolor); boundary_fill(x,y-1,fcolor,bcolor); 8-connected boundary fill Algorithm:- boundary_fill(x, y, f_colour, b_colour) if(getpixel(x, y)! = b_colour && getpixel(x, y)! = f_colour) putpixel(x, y, f_colour); boundary_fill(x + 1, y, f_colour, b_colour); boundary_fill(x - 1, y, f_colour, b_colour); boundary_fill(x, y + 1, f_colour, b_colour); boundary_fill(x, y - 1, f_colour, b_colour); boundary_fill(x + 1, y + 1, f_colour, b_colour); boundary_fill (x - 1, y - 1, f_colour, b_colour); boundary_fill(x + 1, y - 1, f_colour, b_colour); boundary_fill(x - 1, y + 1, f_colour, b_colour); Program: #include<stdio.h> #include<conio.h> #include<graphics.h> #include<dos.h> void boundary_fill(int,int,int,int); void main() int gd,gm; detectgraph(&gd,&gm);

20 initgraph(&gd,&gm,"c:\\turboc3\\bgi"); rectangle(50,50,100,100); boundary_fill(55,55,6,15); getch(); closegraph(); void boundary_fill(int x,int y,int fcolor,int bcolor) if((getpixel(x,y)!=bcolor)&&(getpixel(x,y)!=fcolor)) delay(5); putpixel(x,y,fcolor); boundary_fill(x+1,y,fcolor,bcolor); boundary_fill(x-1,y,fcolor,bcolor); boundary_fill(x,y+1,fcolor,bcolor); boundary_fill(x,y-1,fcolor,bcolor); boundary_fill(x+1,y+1,fcolor,bcolor); boundary_fill(x-1,y+1,fcolor,bcolor); boundary_fill(x+1,y-1,fcolor,bcolor); boundary_fill(x-1,y-1,fcolor,bcolor); void fillcolor(int x,int y,int old_color,int new_color) if(getpixel(x,y)==old_color) putpixel(x,y,new_color); fillcolor(x+1,y,old_color,new_color); fillcolor(x-1,y,old_color,new_color); fillcolor(x,y+1,old_color,new_color); fillcolor(x,y-1,old_color,new_color); boundary_fill(x, y, f_colour, b_colour) if(getpixel(x, y)! = b_colour && getpixel(x, y)! = f_colour) putpixel(x, y, f_colour); boundary_fill(x + 1, y, f_colour, b_colour); boundary_fill(x, y + 1, f_colour, b_colour); boundary_fill(x -1, y, f_colour, b_colour); boundary_fill(x, y 1, f_colour, b_colour);

21 void fillcolor(int x,int y,int old_color,int new_color) if(getpixel(x,y)==old_color) putpixel(x,y,new_color); fillcolor(x+1,y,old_color,new_color); fillcolor(x-1,y,old_color,new_color); fillcolor(x,y+1,old_color,new_color); fillcolor(x,y-1,old_color,new_color); fillcolor(x+1,y+1,old_color,new_color); fillcolor(x+1,y-1,old_color,new_color); fillcolor(x-1,y-1,old_color,new_color); fillcolor(x-1,y+1,old_color,new_color); boundary_fill(x, y, f_colour, b_colour) if(getpixel(x, y)! = b_colour && getpixel(x, y)! = f_colour) putpixel(x, y, f_colour); boundary_fill(x + 1, y, f_colour, b_colour); boundary_fill(x - 1, y, f_colour, b_colour); boundary_fill(x, y + 1, f_colour, b_colour); boundary_fill(x, y - 1, f_colour, b_colour); boundary_fill(x + 1, y + 1, f_colour, b_colour); boundary_fill (x - 1, y - 1, f_colour, b_colour); boundary_fill(x + 1, y - 1, f_colour, b_colour); boundary_fill(x - 1, y + 1, f_colour, b_colour); Scan Line Fill Algorithm To successfully fill in a polygon three main components will be used: Edge Buckets, an Edge Table and an Active List. These components will contain an edge s information, hold all of the edges that compose the figure and maintain the current edges being used to fill in the polygon, respectively. When a scan line intersects an edge endpoint, it intersects two edges. Consider, Two cases: Case A: edges are monotonically increasing or decreasing, we should consider this as only ONE edge intersection Case B: edges reverse direction at endpoint; we should consider this as TWO edge intersections

22 Stepwise Procedure 1. Read n, the number of vertices of polygon. 2. Read x and y coordinates of all vertices in array X[n] and y[n]. 3. Find y max and y min 4. Store the initial x value (x1),y values (y1 and y2) and x increment dx from scan line to scan line for each edge in the array edges[n] [4]. a. While doing this check that y1> y2, if not, interchange y1 and y2 corresponding x1 and x2 so that for each edge, y1 represents its maximum y coordinate and y2 represents its minimum y coordinate. 5. Sort the rows of array, edges[n] [4] in descending order of y1, descending order of y2, and ascending order of x2 6. Set y=y max 7. Find the active edges and update active edge list: a. if ( y>y2 and y<y1) i edge is active b. Else i edge is not active 8. Compute the x intersects for all active edges for current y value. Initially x intersect is x1 and x intersects for successive y values can be given as a. x(i+1)dxi+dx b. where dx=-1/m and m=y2-y1/x2-x1 i.e..slope of a line segment. 9. if x intersect is vertex i.e. x intersect =x1 and y=y1 then apply vertex test to check whether to consider one intersect or two intersects. Store all x intersects in the x intersects array. 10. Store x intersects array in the ascending order. 11. Extract pairs of intersects from the sorted x intersect array. 12. Pass pairs of x values to line drawing routine to draw corresponding line segments. 13.-set y=y Repeat steps 7 through 13 until y> ymin

23 15. Stop Program: #include <stdio.h> #include <conio.h> #include <graphics.h> main() int n,i,j,k,gd,gm,dy,dx; int x,y,temp; int a[20][2],xi[20]; float slope[20]; clrscr(); printf("\n\n\tenter the no. of edges of polygon : "); scanf("%d",&n); printf("\n\n\tenter the cordinates of polygon :\n\n\n "); for(i=0;i<n;i++) printf("\tx%d Y%d : ",i,i); scanf("%d %d",&a[i][0],&a[i][1]); a[n][0]=a[0][0]; a[n][1]=a[0][1]; detectgraph(&gd,&gm); initgraph(&gd,&gm,"c:\\turboc3\\bgi"); /*- draw polygon -*/ for(i=0;i<n;i++) line(a[i][0],a[i][1],a[i+1][0],a[i+1][1]); getch();

24 for(i=0;i<n;i++) dy=a[i+1][1]-a[i][1]; dx=a[i+1][0]-a[i][0]; if(dy==0) slope[i]=1.0; if(dx==0) slope[i]=0.0; if((dy!=0)&&(dx!=0)) /*- calculate inverse slope -*/ slope[i]=(float) dx/dy; for(y=0;y< 480;y++) k=0; for(i=0;i<n;i++) if( ((a[i][1]<=y)&&(a[i+1][1]>y)) ((a[i][1]>y)&&(a[i+1][1]<=y))) xi[k]=(int)(a[i][0]+slope[i]*(y-a[i][1])); k++; for(j=0;j<k-1;j++) /*- Arrange x-intersections in order -*/ for(i=0;i<k-1;i++) if(xi[i]>xi[i+1]) temp=xi[i]; xi[i]=xi[i+1]; xi[i+1]=temp; setcolor(35);

25 for(i=0;i<k;i+=2) line(xi[i],y,xi[i+1]+1,y); getch(); Scan conversion The process of representing continuous graphics objects as a collection of discrete pixels is called scan conversion. Scan conversion serves as a bridge between TV and computer graphics technology. Scan conversion or scan converting rate is a video processing technique for changing the vertical / horizontal scan frequency of video signal for different purposes and applications. The device which performs this conversion is called a scan converter. The application of scan conversion: video projectors, cinema equipment, TV and video capture cards, standard and HDTV televisions, LCD monitors, radar displays and many different aspects of picture processing. There are two distinct methods for changing a picture's data rate: Analog Methods (Non retentive, memory-less or real time method) This conversion is done using large numbers of delay cells and is appropriate for analog video.it may also be performed using a specialized scan converter vacuum tube. In this case polar coordinates (angle and distance) data from a source such as a radar receiver, so that it can be displayed on a raster scan (TV type) display. Digital methods (Retentive or buffered method) In this method, a picture is stored in a line or frame buffer with n1 speed (data rate) and is read with n2 speed.

26 Frame buffer: Each screen pixel corresponds to a particular entry in a 2D array residing in memory. This memory is called a frame buffer or a bit map. The number of rows in the frame buffer equals to the number of raster lines on the display screen. The number of columns in this array equals to the number of pixels on each raster line. Frame buffer is a large part of computer memory used to store display image. Different kind of memory can be used for frame buffers like drums, disk or IC shift registers. To generate a pixel of desired intensity to read the disk or drum. The information stored in disk or drum is in digital for, hence it is necessary to convert it into analog from using DAC and then this analog signal is used to generate the pixel. Character Generation Most of the times characters are builts into the graphics display devices, usallay as hardware but sometimes through software. There are basic three methods:

27 Stroke method Starbust method Bitmap method 1. Stroke method This method uses small line segments to generate a character. The small series of line segments are drawn like a strokes of a pen to form a character as shown in figure. We can build our own stroke method. By calling a line drawing algorithm. Here it is necessary to decide which line segments are needed for each character and Then drawing these segments using line drawing algo. This method supports scaling of the character. 2. Starbust method It does this by changing the length of the line segments used for character drawing. In this method a fix pattern of line segments are used to generate characters. As shown in figure, there are 24 line segments. Out of 24 line segments, segments required to display for particular character, are highlighted This method is called starbust method because of its characteristic appearance.

28 This method of character generation has some disadvantages. They are 1. The 24-bits are required to represent a character. Hence more memory is required 2. Requires code conversion software to display character from its 24-bit code 3. Character quality is poor. It is worst for curve shaped characters. 3. Bitmap Method Also known as dot matrix because in this method characters are represented by an array of dots in the matrix form. It s a two dimensional array having columns and rows : 5 X 7 as shown in figure. 7 X 9 and 9 X 13 arrays are also used. Higher resolution devices may use character array 100 X 100.