Windowing And Clipping (14 Marks)

Transcription

1 Window: 1. A world-coordinate area selected for display is called a window. 2. It consists of a visual area containing some of the graphical user interface of the program it belongs to and is framed by a window decoration. 3. A window defines a rectangular area in world coordinates. Viewport: 1. An area on a display device to which a window is mapped is called a viewport. 2. A viewport is a polygon viewing region in computer graphics. The viewport is an area expressed in rendering-device-specific coordinates, e.g. pixels for screen coordinates, in which the objects of interest are going to be rendered. Window to viewport transformation: The window defines what is to be viewed; the viewport defines where it is to be displayed. 1. Window-to-Viewport transformation is the process of transforming a two-dimensional, world-coordinate scene to device coordinates. 2. In particular, objects inside the world or clipping window are mapped to the viewport. The viewport is displayed in the interface window on the screen. Figure: window and viewport The picture is stored in the computer memory using any convenient Cartesian co-ordinate system, referred to as World Co-Ordinate System (WCS). However, when picture is displayed on the display device it is measured in Physical Device Co-Ordinate System (PDCS) corresponding to the display device. The viewing transformation which maps picture co-ordinates in the WCS to display co-ordinates in PDCS is performed by the following transformations.

2 Converting world co-ordinates to viewing co-ordinates. Normalizing viewing co-ordinates. Converting normalized viewing co-ordinates to device co-ordinates. Figure: Two-dimensional viewing-transformation pipeline. The steps involved in viewing transformation:- 1. Construct the scene in world co-ordinate using the output primitives and attributes. 2. Obtain a particular orientation for the window by setting a two-dimensional viewing co-ordinate system in the world co-ordinate plane and define a window in the viewing co-ordinate system. 3. Use viewing co-ordinates reference frame to provide a method for setting up arbitrary orientations for rectangular windows. 4. Once the viewing reference frame is established, transform descriptions in world co-ordinates to viewing co-ordinates. 5. Define a view port in normalized co-ordinates and map the viewing co-ordinates description of the scene to normalized co-ordinates. 6. Clip all the parts of the picture which lie outside the viewport. Line clipping: In line clipping, we will cut the portion of line which is outside of window and keep only the portion that is inside the window. Cohen Sutherland Line Clipping Algorithm Different cases which are to be consider before clipping line are, i) Completely inside. ii) Completely outside. iii) Partly inside.

3 As shown in fig three lines are given in which one line is inside window so that is displayed, second line is completely outside so it is discarded after clipping, and third line is clipped as it is partially in so that much part is displayed and remaining part is discarded. Line clipping in given window.

4 Algorithm: 1. Read 2 end points of line as p1(x1,y1) and p2(x2,y2) 2. Read 2 corner points of the clipping window (left-top and right-bottom) as (wx1,wy1) and (wx2,wy2) 3. Assign the region codes for 2 endpoints p1 and p2 using following steps:- initialize code with 0000 Set bit 1 if x<wx1 Set bit 2 if x>wx2 Set bit 3 if y<wy2 Set bit 4 if y>wy1 4. Check for visibility of line a. If region codes for both endpoints are zero then line is completely visible. Draw the line go to step 9. b. If region codes for endpoints are not zero and logical ANDing of them is also nonzero then line is invisible. Discard the line and move to step 9. c. If it does not satisfy 4.a and 4.b then line is partially visible. 5. Determine the intersecting edge of clipping window as follows:- a. If region codes for both endpoints are nonzero find intersection points p1 and p2 with boundary edges. b. If region codes for any one end point is non zero then find intersection point p1 or p2. 6. Divide the line segments considering intersection points.

5 7. Reject line segment if any end point of line appears outside of any boundary. 8. Draw the clipped line segment. 9. Stop. Program: #include<stdio.h> #include<graphics.h> void main() int gd=detect, gm; float i,xmax,ymax,xmin,ymin,x11,y11,x22,y22,m; float a[4],b[4],c[4],x1,y1; clrscr(); initgraph(&gd,&gm,"c:\\turboc3\\bgi"); printf("\nenter the bottom-left coordinate of viewport: "); scanf("%f %f",&xmin,&ymin); printf("\nenter the top-right coordinate of viewport: "); scanf("%f %f",&xmax,&ymax); rectangle(xmin,ymin,xmax,ymax); printf("\nenter the coordinates of 1st end point of line: "); scanf("%f %f",&x11,&y11); printf("\nenter the coordinates of 2nd endpoint of line: "); scanf("%f %f",&x22,&y22); line(x11,y11,x22,y22); for(i=0;i<4;i++) a[i]=0; b[i]=0; m=(y22-y11)/(x22-x11); if(x11<xmin) a[3]=1; if(x11>xmax) a[2]=1; if(y11<ymin) a[1]=1; if(y11>ymax) a[0]=1; if(x22<xmin) b[3]=1; if(x22>xmax) b[2]=1; if(y22<ymin) b[1]=1; if(y22>ymax) b[0]=1; printf("\nregion code of 1st pt "); for(i=0;i<4;i++)

6 printf("%f",a[i]); printf("\nregion code of 2nd pt "); for(i=0;i<4;i++) printf("%f",b[i]); printf("\nanding : "); for(i=0;i<4;i++) c[i]=a[i]&&b[i]; for(i=0;i<4;i++) printf("%f",c[i]); getch(); if((c[0]==0)&&(c[1]==0)&&(c[2]==0)&&(c[3]==0)) if((a[0]==0)&&(a[1]==0)&&(a[2]==0)&&(a[3]==0)&& (b[0]==0)&&(b[1]==0)&&(b[2]==0)&&(b[3]==0)) clrscr(); clearviewport(); printf("\nthe line is totally visible\nand not a clipping candidate"); rectangle(xmin,ymin,xmax,ymax); line(x11,y11,x22,y22); getch(); else clrscr(); clearviewport(); printf("\nline is partially visible"); rectangle(xmin,ymin,xmax,ymax); line(x11,y11,x22,y22); getch(); if((a[0]==0)&&(a[1]==1)) x1=x11+(ymin-y11)/m; x11=x1; y11=ymin; else if((b[0]==0)&&(b[1]==1)) x1=x22+(ymin-y22)/m; x22=x1; y22=ymin;

7 if((a[0]==1)&&(a[1]==0)) x1=x11+(ymax-y11)/m; x11=x1; y11=ymax; else if((b[0]==1)&&(b[1]==0)) x1=x22+(ymax-y22)/m; x22=x1; y22=ymax; if((a[2]==0)&&(a[3]==1)) y1=y11+m*(xmin-x11); y11=y1; x11=xmin; else if((b[2]==0)&&(b[3]==1)) y1=y22+m*(xmin-x22); y22=y1; x22=xmin; if((a[2]==1)&&(a[3]==0)) y1=y11+m*(xmax-x11); y11=y1; x11=xmax; else if((b[2]==1)&&(b[3]==0)) y1=y22+m*(xmax-x22); y22=y1; x22=xmax; clrscr(); clearviewport(); printf("\nafter clippling:"); rectangle(xmin,ymin,xmax,ymax); line(x11,y11,x22,y22); getch(); else

8 clrscr(); clearviewport(); printf("\nline is invisible"); rectangle(xmin,ymin,xmax,ymax); getch(); closegraph(); getch(); Reference : Cyrus Beck algorithm Convex region, boundary point and inner normal Cyrus and Beck developed an algorithm for clipping to arbitrary convex regions. Cyrus- Beck algorithm uses the normal vector for determining whether a point is inside, on, or outside a window. Consider a convex planar polygon R. Consider the parametric representation of a line from P1 to P2. If f is a boundary point of the convex region R and n is an inner normal for one of its boundaries, then for any particular value of t, i.e. any particular point on line P1P2.

9 Together these conditions show that for a convex polygon, an infinite line, which intersects the boundary of the region, does so at precisely two points. Further, these two points do not lie on the same boundary edge. Thus n [P(t) f] = 0 has only one solution. If the point f lies in the boundary edge for which n is the inner normal, then that point (t) on the line P(t) which satisfies this condition is the intersection of the line and the boundary edge. Algorithm:

10 Liang-Barsky Line Clipping The ideas for clipping line of Liang-Barsky and Cyrus-Beck are the same. The only difference is Liang-Barsky algorithm has been optimized for an upright rectangular clip window. Liang and Barsky have created an algorithm that uses floating-point arithmetic but finds the appropriate end points with at most four computations. This algorithm uses the parametric equations for a line and solves four inequalities to find the range of the parameter for which the line is in the viewport. 1. parametric equation of line segment: X = X1 + U ΔX Y = Y1 + U ΔY Where, ΔX = X2 X1 and ΔY = Y2 Y1

11 2. Using these equations Cyrus and Beck developed an algorithm that is generated more efficient than the Cohen Sutherland algorithm. 3. Later Liang and Barsky independently devised an even faster parametric line clipping algorithm. 4. In the Liang-Barsky approach we first the point clipping condition in parametric form: Xmin X1+UΔX XmaxXmin X1+UΔX Xmax Ymin Y1+UΔY YmaxYmin Y1+UΔY Ymax 5. Each of these four inequalities can be expressed as: μpk qk for k=1,2,3,4 6. The parameters p & q are defined as: p1 = -ΔX and q1 = X1 Xmin (Left Boundary) p2 = ΔX and q2 = Xmax - x1 (Right Boundary) P3 = -ΔY and q3 = Y1- Ymin (Bottom Boundary) P4 = ΔY and q4 = Ymax - y1 (Top Boundary) 7. If a line is parallel to a view window boundary, the p value for that boundary is zero. 8. If the line is parallel to the X axis, for example then p1 and p2 must be zero. o o Given pk = 0, if qk < 0 then line is trivially invisible because it is outside view window. Given pk = 0, if qk > 0 then the line is inside the corresponding window boundary. 9. When pk < 0, as U increase line goes from the outside to inside i.e. entering. 10. When pk > 0, line goes from inside to outside i.e. exiting. 11. If there is a segment of line inside the clip region, a sequence of infinite line intersections must go entering, entering, exiting, and exiting as shown in figure.

12 Algorithm:

13 Advantages 1. More efficient than other algorithms as line intersection with boundaries calculations are reduced. 2. Intersections of line are computed only once. Program for Line Clipping Using Liang Barsky Algorithm: #include<stdio.h> #include<conio.h>

14 #include<graphics.h> #include<dos.h> #define ROUND(a)((int)(a+0.5)) int cliptest(float p,float q,float *u1,float *u2) float r; int retval=1; if(p<0.0) r=q/p; if(r>*u2) retval=0; if(r>*u1) *u1=r; else if(p>0.0) r=q/p; if(r<*u1) retval=0; if(r<*u2) *u2=r; else if(q<0.0) retval=0; return(retval); void clipline(int minx,int miny,int maxx,int maxy,int x1,int y1,int x2,int y2) float u1=0.0,u2=1.0,dx=x2-x1,dy; if(cliptest(-dx,x1-minx,&u1,&u2)) if(cliptest(dx,maxx-x1,&u1,&u2)) dy=y2-y1; if(cliptest(-dy,y1-miny,&u1,&u2)) if(cliptest(dy,maxy-y1,&u1,&u2)) if(u2<1.0) x2=x1+u2*dx;

15 y2=y1+u2*dy; if(u1>0.0) x1+=u1*dx; y1+=u1*dy; line(x1,y1,x2,y2); void main() int gdriver=detect,gmode,x1,y1,x2,y2,minx,miny,maxx,maxy; initgraph(&gdriver,&gmode,"c:\\turboc3\\bgi"); clrscr(); printf("enter the min & max x values: "); scanf("%d %d",&minx,&maxx); printf("enter the min & max y values: "); scanf("%d %d",&miny,&maxy); printf("enter the first endpoint: "); scanf("%d %d",&x1,&y1); printf("enter the second endpoint: "); scanf("%d %d",&x2,&y2); clrscr(); printf("before Clipping"); line(x1,y1,x2,y2); rectangle(minx,maxy,maxx,miny); getch(); clrscr(); printf("after Clipping"); clipline(minx,miny,maxx,maxy,x1,y1,x2,y2); rectangle(minx,maxy,maxx,miny); getch(); Midpoint subdivision algorithm: Midpoint subdivision algorithm is an extension of the Cyrus Beck algorithm. This algorithm is mainly used to compute visible areas of lines that are present in the view port are of the sector or the image.

16 Algorithm : 1)Read two end points of line P1 (x1,y1) and P2 (x2,y2). 2) Read corners of window (Wx1, Wy1) and (Wx2, Wy2). 3) Assign region codes for P1 and P2. A region code is a 4 digit bit code which indicates one of nine regions having the end point of line. Initialize code with bits 0000 Set Bit 1 if (x<wx1) Set Bit 2 if (x>wx2) Set Bit 3 if (y<wy2) Set Bit 4 if (y>wy1) 4) Check visibility of line P1P2 a) If region codes for both end points P1 and P2 are 0 = > Line is completely visible. Draw Line and Go to Step 3. b) If region codes for both end points P1 and P2 are not 0 and logical ANDing of them is also not zero = > Line is completely invisible. Reject line and Go to Step 3. c) If a) and b) both are not satisfied, line is partially visible.

17 5) Divide partially visible line segments to equal parts and repeat steps 3 through 5 for both sub divided line segments until you get completely visible and completely invisible line segments. 6) Stop. Program: //MIDPOINT SUBDIVISION LINE CLIPPING #include<stdio.h> #include<conio.h> #include<stdlib.h> #include<dos.h> #include<math.h> #include<graphics.h> typedef struct coordinate int x,y; char code[4]; PT; void drawwindow(); void drawline (PT p1,pt p2,int cl); PT setcode(pt p); int visibility (PT p1,pt p2); PT resetendpt (PT p1,pt p2); main() int gd=detect, gm,v; PT p1,p2,ptemp; initgraph(&gd,&gm,"c:\\turboc3\\bgi "); cleardevice(); printf("\n\n\t\tenter END-POINT 1 (x,y): "); scanf("%d%d",&p1.x,&p1.y); printf("\n\n\t\tenter END-POINT 2 (x,y): "); scanf("%d%d",&p2.x,&p2.y); cleardevice(); drawwindow(); getch(); drawline(p1,p2,15); getch();

18 cleardevice(); drawwindow(); midsub(p1,p2); getch(); closegraph(); return(0); midsub(pt p1,pt p2) PT mid; int v; p1=setcode(p1); p2=setcode(p2); v=visibility(p1,p2); switch(v) case 0: /* Line conpletely visible */ drawline(p1,p2,15); break; case 1: /* Line completely invisible */ break; case 2: /* line partly visible */ mid.x = p1.x + (p2.x-p1.x)/2; mid.y = p1.y + (p2.y-p1.y)/2; midsub(p1,mid); mid.x = mid.x+1; mid.y = mid.y+1; midsub(mid,p2); break; void drawwindow() setcolor(red); line(150,100,450,100); line(450,100,450,400); line(450,400,150,400); line(150,400,150,100);

19 void drawline (PT p1,pt p2,int cl) setcolor(cl); line(p1.x,p1.y,p2.x,p2.y); PT setcode(pt p) PT ptemp; if(p.y<=100) ptemp.code[0]='1'; /* TOP */ else ptemp.code[0]='0'; if(p.y>=400) ptemp.code[1]='1'; /* BOTTOM */ else ptemp.code[1]='0'; if (p.x>=450) ptemp.code[2]='1'; /* RIGHT */ else ptemp.code[2]='0'; if (p.x<=150) /* LEFT */ ptemp.code[3]='1'; else ptemp.code[3]='0'; ptemp.x=p.x; ptemp.y=p.y; return(ptemp); int visibility (PT p1,pt p2) int i,flag=0; for(i=0;i<4;i++) if((p1.code[i]!='0') (p2.code[i]!='0')) flag=1; if(flag==0)

20 return(0); for(i=0;i<4;i++) if((p1.code[i]==p2.code[i]) &&(p1.code[i]=='1')) flag=0; if(flag==0) return(1); return(2); Polygon clipping: There are several well-known polygon clipping algorithms, each having its strengths and weaknesses. The oldest one (from 1974) is called the Sutherland-Hodgman algorithm. In its basic form, it is relatively simple. It is also very efficient in two important cases, one being when the polygon is completely inside the boundaries, and the other when it's completely outside. Sutherland - Hodgeman Polygon Clipping: Each edge of the polygon must be tested against each edge of the clip rectangle. New edges must be added, and existing edges must be discarded, retained, or divided. Multiple polygons may result from clipping a single polygon. We need an organized way to deal with all these cases. Steps of Sutherland-Hodgeman's polygon clipping algorithm: i. Polygons can be clipped against each edge of the window one at a time. ii. Vertices which are kept after clipping against one window edge are saved for clipping against the remaining edges. iii. Note that the number of vertices usually changes and will often increases.

21 Four Cases of polygon clipping against one Edge: The clip boundary determines a visible and invisible region. The edges from vertex can be one of four types: Case 1: If the first vertex is outside the window boundary and the second vertex is inside the window, then the intersection point with the boundary edge of window and vertex which is inside the window is stored in a output vertex list. Case 2: If both, first and second vertexes of a polygon are lying inside the window, and then we have to store the second vertex only in output vertex list. Case 3: If the first vertex is inside the window and second vertex is outside the window then we have to store only intersection point of that edge of polygon with window in output vertex list. Case 4: If both the vertex first and second vertex of a polygon is lying outside the window then no vertex is stored in output vertex list.

22 Algorithm: Program: