多边形的裁剪

实现了两种二维图形裁剪算法：Sutherland-Hodgeman单边裁剪法和Weiler-Atherton边界裁剪法，关于这两个算法的具体可以参看这个网址：http://course.cug.edu.cn/cugFirst/computer_graphics/class/start.asp

 

1. #include <stdio.h>
2. #include <alloc.h>
3. #include <graphics.h>
4. #include <math.h>
6. typedef enum 
7. {
8.     FALSE  = 0,
9.     TRUE = 1
10. } BOOL;
12. typedef enum
13. {
14.     INSIDE,
15.     EDGE_IN,
16.     EDGE_OUT,
17.     EDGE_CORNER,
18.     OUTSIDE,
19.     UNKNOWN
20. } VectorType;
22. typedef struct
23. {
24.     int x;
25.     int y;
26.     VectorType type;
27. } Vector;
29. typedef struct
30. {
31.     Vector v1;
32.     Vector v2;
33. } Edge;
35. typedef struct _Node
36. {
37.     Vector v;
38.     struct _Node *next;
39. } Node, *VectorList;
41. const Vector AREA_LEFT_TOP = { 145, 125 };
42. const Vector AREA_RIGHT_BOTTOM = { 260, 190 };
44. typedef enum
45. {
46.     LEFT,
47.     TOP,
48.     RIGHT,
49.     BOTTOM,
50.     AROUND
51. } EdgeType;
54. #define VECTOR_NUM 7
55. const Vector PRIMITIVE_LEFT_TOP = { 100, 100 };
57. BOOL Clockwise( Vector v1, Vector v2 )
58. {
59.     int n = v1.x * v2.y - v1.y * v2.x;
60.     if ( n > 0 )
61.     {
62.         return TRUE;
63.     }
64.     else
65.     {
66.         return FALSE;
67.     }
68. }
70. void Push( VectorList *vList, Node *frontNode, Node *pushingNode )
71. {
72.     Node *n;
73.     if ( *vList == NULL || frontNode == NULL )
74.     {
75.         printf( "error in Push;" );
76.         return;
77.     }
78.     pushingNode->next = frontNode->next;
79.     frontNode->next = pushingNode;
80. }
82. void PushBack( VectorList *vList, Node *pushingNode )
83. {
84.     Node *n;
86.     pushingNode->next = NULL;
87.     if ( *vList == NULL )
88.     {
89.         *vList = pushingNode;
90.     }
91.     else
92.     {
93.         for ( n = *vList; n->next != NULL; n = n->next );
94.         n->next = pushingNode;
95.     }
96. }
98. void Erase( VectorList *vList, Node **erasingNode )
99. {
100.     Node *n;
101.     if ( *vList == NULL )
102.     {
103.         printf( "error in Erase" );
104.         return;
105.     }
106.     if ( *erasingNode == *vList )
107.     {
108.         *vList = ( *vList )->next;
109.         free( *erasingNode );
110.         return;
111.     }
112.     for ( n = *vList; n->next != *erasingNode && n->next != NULL; n = n->next );
113.     if ( n->next == NULL )
114.     {
115.         printf( "can not find node in Erase" );
116.         return;
117.     }
118.     n->next = ( *erasingNode )->next;
119.     free( *erasingNode );
120. }
122. /* 获得顶点列表的索引为i的元素, 0 <= i < numVector */
123. Node* GetVector( VectorList vList, int i )
124. {
125.     int j;
126.     Node *n;
128.     for ( j = 0, n = vList; j < i && n->next != NULL; i++, n = n->next );
129.     return n;
130. }
132. BOOL InsideEdge( Vector v, EdgeType type )
133. {
134.     switch ( type )
135.     {
136.     case ( LEFT ) :
137.         return v.x >= AREA_LEFT_TOP.x;
138.     case ( RIGHT ) :
139.         return v.x <= AREA_RIGHT_BOTTOM.x;
140.     case ( TOP ) :
141.         return v.y >= AREA_LEFT_TOP.y;
142.     case ( BOTTOM ) :
143.         return v.y <= AREA_RIGHT_BOTTOM.y;
144.     case ( AROUND ):
145.         return v.x >= AREA_LEFT_TOP.x &
146.             v.x <= AREA_RIGHT_BOTTOM.x &
147.             v.y >= AREA_LEFT_TOP.y &
148.             v.y <= AREA_RIGHT_BOTTOM.y;
149.     default :
150.         return FALSE;
151.     }
152. }
154. /* 检测一条边与某个边界的交点 */
155. Vector CalcIntersectPoint( Edge e, EdgeType type )
156. {
157.     Vector res = { -1, -1 };
158.     float x0, x1, y0, y1;
159.     x0 = e.v1.x;
160.     x1 = e.v2.x;
161.     y0 = e.v1.y;
162.     y1 = e.v2.y;
163.     switch ( type )
164.     {
165.     case ( LEFT ) :
166.         if ( x1 - x0 != 0 )
167.         {
168.             res.x = AREA_LEFT_TOP.x;
169.             res.y = floor( res.x * ( y1 - y0 ) / ( x1 - x0 ) + ( x1 * y0 - x0 * y1 ) / ( x1 - x0 ) + 0.5f );
170.             return res;
171.         }
172.         else
173.         {
174.             printf( "error LEFT" );
175.             return res;
176.         }
177.     case ( RIGHT ) :
178.         if ( x1 - x0 != 0 )
179.         {
180.             res.x = AREA_RIGHT_BOTTOM.x;
181.             res.y = floor( res.x * ( y1 - y0 ) / ( x1 - x0 ) + ( x1 * y0 - x0 * y1 ) / ( x1 - x0 ) + 0.5f );
182.             return res;
183.         }
184.         else
185.         {
186.             printf( "error RIGHT" );
187.             return res;
188.         }
189.     case ( TOP ) :
190.         if ( y1 - y0 != 0 )
191.         {
192.             res.y = AREA_LEFT_TOP.y;
193.             res.x = floor( res.y * ( x1 - x0 ) / ( y1 - y0 ) + ( x0 * y1 - x1 * y0 ) / ( y1 - y0 ) + 0.5f );
194.             return res;
195.         }
196.         else
197.         {
198.             printf( "error TOP" );
199.             return res;
200.         }
201.     case ( BOTTOM ) :
202.         if ( y1 - y0 != 0 )
203.         {
204.             res.y = AREA_RIGHT_BOTTOM.y;
205.             res.x = floor( res.y * ( x1 - x0 ) / ( y1 - y0 ) + ( x0 * y1 - x1 * y0 ) / ( y1 - y0 ) + 0.5f );
206.             return res;
207.         }
208.         else
209.         {
210.             printf( "error BOTTOM" );
211.             return res;
212.         }
213.     default :
214.         printf( "unknown type" );
215.     }
217.     /* should never be here */
218.     return res;
219. }
221. /* 单边裁剪 */
222. void SingleEdgeClipping( Vector primitive[], int numVector )
223. {
224.     int i;
225.     VectorList vList = NULL;
226.     Node *n = NULL, *m = NULL;
227.     Vector vTemp, vNext;
228.     Vector v1, v2;
229.     Edge eTemp;
230.     BOOL in1, in2;
231.     EdgeType type;
233.     /* 顺时针序列转为逆时针序列 */
234.     for ( i = numVector - 1; i >= 0; i-- )
235.     {
236.         n = ( Node* )malloc( sizeof( Node ) );
237.         n->v = primitive[i];
238.         n->next = NULL;
239.         PushBack( &vList, n );
240.     }
242.     /* 分别对左右上下四个边界作单边裁剪 */
243.     for ( type = LEFT; type <= BOTTOM; type++ )
244.     {
245.         n = vList;
246.         /* 遍历顶点列表 */
247.         while ( n != NULL )
248.         {
249.             /*printf( "cur(%d,%d) ", n->v.x - PRIMITIVE_LEFT_TOP.x, n->v.y - PRIMITIVE_LEFT_TOP.y );*/
250.             in1 = InsideEdge( n->v, type );
251.             if ( n->next == NULL )
252.             {
253.                 vNext = vList->v;
254.             }
255.             else
256.             {
257.                 vNext = n->next->v;
258.             } 
259.             in2 = InsideEdge( vNext, type );
262.             if ( in1 == TRUE ) /* 当前遍历的顶点在边界以内 */
263.             {
264.                 if ( in2 == TRUE ) /* 下一个顶点在边界以内 */
265.                 {
266.                     n = n->next;;
267.                 }
268.                 else
269.                 {
270.                     /* 求与边界的交点 */
271.                     eTemp.v1 = n->v;
272.                     eTemp.v2 = vNext;
273.                     vTemp = CalcIntersectPoint( eTemp, type );
274.                     /* 将交点添加到List，添加到当前遍历顶点的后面 */
275.                     m = ( Node* )malloc( sizeof( Node ) );
276.                     m->v = vTemp;
277.                     m->next = NULL;
278.                     Push( &vList, n, m); 
279.                     /*printf("add(%d,%d) ", m->v.x - PRIMITIVE_LEFT_TOP.x, m->v.y - PRIMITIVE_LEFT_TOP.y );*/
281.                     /* 跳过当前新添加的节点 */
282.                     n = m->next;
283.                 }
284.             }
285.             else
286.             {
287.                 if ( in2 == TRUE )
288.                 {
289.                     /* 求与边界的交点 */
290.                     eTemp.v1 = n->v;
291.                     eTemp.v2 = vNext;
292.                     vTemp = CalcIntersectPoint( eTemp, type );
293.                     /* 将交点添加到List，添加到当前遍历顶点的后面 */
294.                     m = ( Node* )malloc( sizeof( Node ) );
295.                     m->v = vTemp;
296.                     m->next = NULL;
297.                     Push( &vList, n, m);
298.                     /*printf("add(%d,%d) ", m->v.x - PRIMITIVE_LEFT_TOP.x, m->v.y - PRIMITIVE_LEFT_TOP.y );*/
300.                     m = n;
301.                     /* 跳过当前新添加的节点 */
302.                     n = n->next->next;
303.                     /* 从顶点列表中删除当前节点 */
304.                     /*printf("del(%d,%d) ", m->v.x - PRIMITIVE_LEFT_TOP.x, m->v.y - PRIMITIVE_LEFT_TOP.y );*/
305.                     Erase( &vList, &m );
307.                 }
308.                 else
309.                 {
310.                     m = n;
311.                     n = n->next;
312.                     /* 从顶点列表中删除当前节点 */
313.                     /*printf("del(%d,%d) ", m->v.x - PRIMITIVE_LEFT_TOP.x, m->v.y - PRIMITIVE_LEFT_TOP.y );*/
314.                     Erase( &vList, &m );
315.                 }
316.             }
317.         }
319.         /*
320.         n = vList;
321.         while ( n != NULL )
322.         {
323.             printf("(%d,%d)", n->v.x - PRIMITIVE_LEFT_TOP.x, n->v.y - PRIMITIVE_LEFT_TOP.y);
324.             n = n->next;
325.         }
326.         printf("/n");
327.         */
328.     }
330.     n = vList;
331.     setlinestyle( SOLID_LINE, 0, 3 );
332.     setcolor( RED );
333.     while ( n->next != NULL )
334.     {
335.         line( n->v.x, n->v.y, n->next->v.x, n->next->v.y );
336.         n = n->next;
337.     }
338.     line( n->v.x - PRIMITIVE_LEFT_TOP.x, n->v.y - PRIMITIVE_LEFT_TOP.y, vList->v.x - PRIMITIVE_LEFT_TOP.x, vList->v.y - PRIMITIVE_LEFT_TOP.y );
339. }
341. /* 检测一条边与所有边界的交点，交点可能有1个或两个，函数返回交点数目 */
342. int CalcIntersectPoints( Edge e, Vector vRes[] )
343. {
344.     int n = 0;
345.     EdgeType type;
346.     BOOL b1, b2;
347.     Vector v;
348.     float t1, t2;
350.     for ( type = LEFT; type <= BOTTOM; type++ )
351.     {
352.         b1 = InsideEdge( e.v1, type );
353.         b2 = InsideEdge( e.v2, type );
354.         if ( b1 ^ b2 == 1 ) /* 在边缘的两侧才有可能有交点 */
355.         {
356.             v = CalcIntersectPoint( e, type );
357.             /* 必须保证交点在区域内 */
358.             if ( InsideEdge( v, AROUND ) == TRUE )
359.             {
360.                 vRes[n] = v;
361.                 n++;
362.             }
363.         }
364.     }
365.     if ( n == 2 )
366.     {
367.         t1 = fabs( vRes[0].x - e.v1.x );
368.         t2 = fabs( vRes[1].x - e.v1.x );
369.         /*printf("e.v1(%d,%d)", e.v1.x - PRIMITIVE_LEFT_TOP.x, e.v1.y - PRIMITIVE_LEFT_TOP.y );
370.         printf("sec1(%d,%d)", vRes[0].x - PRIMITIVE_LEFT_TOP.x, vRes[0].y - PRIMITIVE_LEFT_TOP.y );
371.         printf("(t1:%f, t2:%f)", t1, t2 );*/
372.         /* 必须保证第一个交点比第二个交点更接近起点(即e的第一个顶点）*/
373.         if ( t1 > t2 )
374.         {
375.             v = vRes[0];
376.             vRes[0] = vRes[1];
377.             vRes[1] = v;
378.         }
379.     }
381.     if ( n > 2 )
382.     {
383.         printf( "(%d,%d)num wrong(%d)", e.v1.x, e.v1.y, n );
384.     }
385.     return n;
386. }
388. /* 对一边的顶点进行排序 */
389. void SortEdgeVectors( Vector vList[], int numVector, EdgeType type )
390. {
391.     int i, j;
392.     Vector vTemp;
393.     switch ( type )
394.     {
395.         case LEFT:
396.             for ( i = 1; i <= numVector - 1; i++ )
397.             {
398.                 for ( j = 0; j < numVector - i; j++ )
399.                 {
400.                     if ( vList[j].y > vList[j + 1].y )
401.                     {
402.                         /* 交换vList[j]和vList[j + 1] */
403.                         vTemp = vList[j];
404.                         vList[j] = vList[j + 1];
405.                         vList[j + 1] = vTemp;
406.                     }
407.                 }
408.             }
409.             break;
410.         case TOP:
411.             for ( i = 1; i <= numVector - 1; i++ )
412.             {
413.                 for ( j = 0; j < numVector - i; j++ )
414.                 {
415.                     if ( vList[j].x < vList[j + 1].x )
416.                     {
417.                         /* 交换vList[j]和vList[j + 1] */
418.                         vTemp = vList[j];
419.                         vList[j] = vList[j + 1];
420.                         vList[j + 1] = vTemp;
421.                     }
422.                 }
423.             }
424.             break;
425.         case RIGHT:
426.             for ( i = 1; i <= numVector - 1; i++ )
427.             {
428.                 for ( j = 0; j < numVector - i; j++ )
429.                 {
430.                     if ( vList[j].y < vList[j + 1].y )
431.                     {
432.                         /* 交换vList[j]和vList[j + 1] */
433.                         vTemp = vList[j];
434.                         vList[j] = vList[j + 1];
435.                         vList[j + 1] = vTemp;
436.                     }
437.                 }
438.             }
439.             break;
440.         case BOTTOM:
441.             for ( i = 1; i <= numVector - 1; i++ )
442.             {
443.                 for ( j = 0; j < numVector - i; j++ )
444.                 {
445.                     if ( vList[j].x > vList[j + 1].x )
446.                     {
447.                         /* 交换vList[j]和vList[j + 1] */
448.                         vTemp = vList[j];
449.                         vList[j] = vList[j + 1];
450.                         vList[j + 1] = vTemp;
451.                     }
452.                 }
453.             }
454.             break;
455.         default:
456.             printf( "error in Sort" );
457.             break;
458.     }
459. }
461. /* 边界裁剪 */
462. void EdgeClipping( Vector primitive[], int numVector )
463. {
464.     int i = 0, j = 0, k = 0, l = 0;
465.     /* vList是多边形顶点及插入交点的序列
466.        vEdgeList是区域ABCD四个点及插入交点的序列 */
467.     VectorList vList = NULL;
468.     Node *n = NULL, *m = NULL;
469.     Vector vTemp, vNext;
470.     Vector vIntersect[2];
471.     int num = 0, numIntersect = 0, numEdge = 0;
472.     Vector v1, v2;
473.     Edge eTemp;
474.     VectorType vType;
475.     EdgeType eType;
477.     Vector *polyList = NULL, *edgeList = NULL, *tempList = NULL;
479.     Vector curStart;
480.     Vector *clippedList = NULL;
481.     int numClipped = 0;
483.     /* 顺时针序列转为逆时针序列 */
484.     for ( i = numVector - 1; i >= 0; i-- )
485.     {
486.         n = ( Node* )malloc( sizeof( Node ) );
487.         n->v = primitive[i];
488.         n->next = NULL;
489.         if ( InsideEdge( n->v, AROUND ) )
490.         {
491.             n->v.type = INSIDE;
492.         }
493.         else
494.         {
495.             n->v.type = OUTSIDE;
496.         }
497.         PushBack( &vList, n );
498.     }
500.     /* 求各个交点，初始化vList */
501.     n = vList;
502.     while ( n != NULL )
503.     {
504.         if ( n->next == NULL )
505.         {
506.             vNext = vList->v;
507.         }
508.         else
509.         {
510.             vNext = n->next->v;
511.         }
512.         eTemp.v1 = n->v;
513.         eTemp.v2 = vNext;
514.         num = CalcIntersectPoints( eTemp, vIntersect );
515.         numIntersect += num;
516.         if ( num == 0 )
517.         {
518.             n = n->next;
519.         }
520.         if ( num == 1 )
521.         {
522.             if ( n->v.type == OUTSIDE )
523.             {
524.                 /* 交点是入点 */
525.                 vType = EDGE_IN;
526.             }
527.             else
528.             {
529.                 /* 交点是出点 */
530.                 vType = EDGE_OUT;
531.             }
533.             /* 添加到vList */
534.             m = ( Node* )malloc( sizeof( Node ) );
535.             m->v = vIntersect[0];
536.             m->v.type = vType;
537.             m->next = NULL;
538.             Push( &vList, n, m );
540.             n = n->next->next;
541.         }
542.         else if ( num == 2 )
543.         {
544.             /* 必定第一个交点是入点，第二个交点是出点 */
546.             /* 添加第一个交点到vList */
547.             m = ( Node* )malloc( sizeof( Node ) );
548.             m->v = vIntersect[0];
549.             m->v.type = EDGE_IN;
550.             m->next = NULL;
551.             Push( &vList, n, m );
552.             n = m;
553.             
554.             /* 添加第二个交点到vList */
555.             m = ( Node* )malloc( sizeof( Node ) );
556.             m->v = vIntersect[1];
557.             m->v.type = EDGE_OUT;
558.             m->next = NULL;
559.             Push( &vList, n, m );
560.             n = m;
562.             n = n->next;
563.         }
564.     }
566.     polyList = ( Vector* )malloc( sizeof( Vector ) * ( numVector + numIntersect ) );
567.     edgeList = ( Vector* )malloc( sizeof( Vector ) * ( 4 + numIntersect ) );
568.     tempList = ( Vector* )malloc( sizeof( Vector ) * numIntersect );
569.     /* 初始化polyList */
570.     i = 0;
571.     n = vList;
572.     while ( n != NULL )
573.     {
574.         polyList[i].x = n->v.x;
575.         polyList[i].y = n->v.y;
576.         polyList[i].type = n->v.type;
577.         n = n->next;
578.         i++;
579.     }
580.     /*
581.     for ( i = 0; i < numVector + numIntersect; i++)
582.     {
583.         printf("[%d](%d,%d) ", polyList[i].type, polyList[i].x - PRIMITIVE_LEFT_TOP.x, polyList[i].y - PRIMITIVE_LEFT_TOP.y );
584.     }
585.     printf("/n");
586.     */
588.     /* 初始化edgeList */
589.     numEdge = 0;
590.     /*
591.       按逆时针DCBA
592.       A----------B
593.       |          |
594.       |          |
595.       |          |
596.       D----------C
597.     */
599.     /* 插入D点 */
600.     edgeList[numEdge].x = AREA_LEFT_TOP.x;
601.     edgeList[numEdge].y = AREA_RIGHT_BOTTOM.y;
602.     edgeList[numEdge].type = EDGE_CORNER;
603.     numEdge++;
604.     /* 寻找DC边上的点并排序 */
605.     num = 0;
606.     for ( i = 0; i < numVector + numIntersect; i++ )
607.     {
608.         if ( polyList[i].y == AREA_RIGHT_BOTTOM.y )
609.         {
610.             tempList[num] = polyList[i];
611.             num++;
612.         }
613.     }
614.     SortEdgeVectors( tempList, num, BOTTOM );
615.     /* 插入DC上的点 */
616.     for ( i = 0; i < num; i++ )
617.     {
618.         edgeList[numEdge] = tempList[i];
619.         numEdge++;
620.     }
622.     /* 插入C点 */
623.     edgeList[numEdge].x = AREA_RIGHT_BOTTOM.x;
624.     edgeList[numEdge].y = AREA_RIGHT_BOTTOM.y;
625.     edgeList[numEdge].type = EDGE_CORNER;
626.     numEdge++;
627.     /* 寻找CB边上的点并排序 */
628.     num = 0;
629.     for ( i = 0; i < numVector + numIntersect; i++ )
630.     {
631.         if ( polyList[i].x == AREA_RIGHT_BOTTOM.x )
632.         {
633.             tempList[num] = polyList[i];
634.             num++;
635.         }
636.     }
637.     SortEdgeVectors( tempList, num, RIGHT );
638.     /* 插入CB上的点 */
639.     for ( i = 0; i < num; i++ )
640.     {
641.         edgeList[numEdge] = tempList[i];
642.         numEdge++;
643.     }
645.     /* 插入B点 */
646.     edgeList[numEdge].x = AREA_RIGHT_BOTTOM.x;
647.     edgeList[numEdge].y = AREA_LEFT_TOP.y;
648.     edgeList[numEdge].type = EDGE_CORNER;
649.     numEdge++;
650.     /* 寻找BA边上的点并排序 */
651.     num = 0;
652.     for ( i = 0; i < numVector + numIntersect; i++ )
653.     {
654.         if ( polyList[i].y == AREA_LEFT_TOP.y )
655.         {
656.             tempList[num] = polyList[i];
657.             num++;
658.         }
659.     }
660.     SortEdgeVectors( tempList, num, TOP );
661.     /* 插入BA上的点 */
662.     for ( i = 0; i < num; i++ )
663.     {
664.         edgeList[numEdge] = tempList[i];
665.         numEdge++;
666.     }
668.     /* 插入A点 */
669.     edgeList[numEdge].x = AREA_LEFT_TOP.x;
670.     edgeList[numEdge].y = AREA_LEFT_TOP.y;
671.     edgeList[numEdge].type = EDGE_CORNER;
672.     numEdge++;
673.     /* 寻找AD边上的点并排序 */
674.     num = 0;
675.     for ( i = 0; i < numVector + numIntersect; i++ )
676.     {
677.         if ( polyList[i].x == AREA_LEFT_TOP.x )
678.         {
679.             tempList[num] = polyList[i];
680.             num++;
681.         }
682.     }
683.     SortEdgeVectors( tempList, num, LEFT );
684.     /* 插入AD上的点 */
685.     for ( i = 0; i < num; i++ )
686.     {
687.         edgeList[numEdge] = tempList[i];
688.         numEdge++;
689.     }
690.     /*
691.     for ( i = 0; i < numEdge; i++)
692.     {
693.         printf("[%d](%d,%d) ", edgeList[i].type, edgeList[i].x - PRIMITIVE_LEFT_TOP.x, edgeList[i].y - PRIMITIVE_LEFT_TOP.y );
694.     }
695.     printf("/n");
696.     */
698.     /* 边界裁剪算法开始进行 */
699.     while ( TRUE )
700.     {
701.         /* 初始化输出数组 */
702.         clippedList = ( Vector* )malloc( sizeof( Vector ) * ( numVector + numIntersect ) );
703.         numClipped = 0;
705.         /* 从polyList中找入点 */
706.         for ( i = 0; polyList[i].type != EDGE_IN && i < numVector + numIntersect; i++ );
707.         if ( i == numVector + numIntersect ) /* 没有找到入点，算法终止 */
708.         {
709.             /*printf( "End" );*/
710.             break;
711.         }
712.         /* 将入点记为起始点 */
713.         curStart = polyList[i];
715.         while ( TRUE )
716.         {
717.             /* 入点进clippedList,并将该入点的入点标记删去 */
718.             clippedList[numClipped++] = polyList[i];
719.             /*printf("in(%d, %d)",clippedList[numClipped-1].x- PRIMITIVE_LEFT_TOP.x,clippedList[numClipped-1].y - PRIMITIVE_LEFT_TOP.y );*/
720.             polyList[i].type = UNKNOWN;
721.             /* 寻找出点 */
722.             if ( i == numVector + numIntersect - 1 )
723.             {
724.                 j = 0;
725.             }
726.             else
727.             {
728.                 j = i + 1;
729.             }
730.             while ( TRUE )
731.             {
732.                 if ( polyList[j].type != EDGE_OUT )
733.                 {
734.                     /* 非出点进clippedList */
735.                     clippedList[numClipped++] = polyList[j];
736.                     /*printf("in(%d, %d)",clippedList[numClipped-1].x- PRIMITIVE_LEFT_TOP.x,clippedList[numClipped-1].y - PRIMITIVE_LEFT_TOP.y );*/
737.                 }
738.                 else
739.                 {
740.                     /* 找到了出点, 先把出点也进clippedList */
741.                     clippedList[numClipped++] = polyList[j];
742.                     /*printf("in(%d, %d)",clippedList[numClipped-1].x- PRIMITIVE_LEFT_TOP.x,clippedList[numClipped-1].y - PRIMITIVE_LEFT_TOP.y );*/
743.                     break;
744.                 }
745.                 if ( j == numVector + numIntersect - 1 )
746.                 {
747.                     /* 到了polyList的末尾则调到开始继续寻找 */
748.                     j = 0;
749.                 }
750.                 else if ( j == i )
751.                 {
752.                     /* 错误——没有找到出点！*/
753.                     printf( "error-can not find out point" );
754.                     return;
755.                 }
756.                 else
757.                 {
758.                     j++;
759.                 }
760.             }
761.             /* 从polyList中找到了出点，接着从edgeList中找入点 */
762.             /* 先从edgeList中找到与当前出点相同的点 */
763.             for ( k = 0; edgeList[k].x != polyList[j].x || edgeList[k].y != polyList[j].y && k < numEdge; k++ );
764.             /*printf("eOut(%d,%d)", edgeList[k].x- PRIMITIVE_LEFT_TOP.x,edgeList[k].y - PRIMITIVE_LEFT_TOP.y );*/
765.             if ( k == numEdge )
766.             {
767.                 /* 错误——没有找到与polyList中出点相对应的边缘点！ */
768.                 printf( "error-can not find out point in edgeList/n" );
769.                 return;
770.             }
771.             /* 接着寻找入点 */
772.             if ( k == numEdge - 1 )
773.             {
774.                 l = 0;
775.             }
776.             else
777.             {
778.                 l = k + 1;
779.             }
780.             while ( TRUE )
781.             {
782.                 if ( edgeList[l].type != EDGE_IN )
783.                 {
784.                     /* 非入点进clippedList */
785.                     clippedList[numClipped++] = edgeList[l];
786.                     /*printf("in(%d, %d)",clippedList[numClipped-1].x- PRIMITIVE_LEFT_TOP.x,clippedList[numClipped-1].y - PRIMITIVE_LEFT_TOP.y );*/
787.                 }
788.                 else
789.                 {
790.                     /* 找到了入点 */
791.                     break;
792.                 }
793.                 if ( l == numEdge - 1 )
794.                 {
795.                     /* 到了edgeList的末尾则调到开始继续寻找 */
796.                     l = 0;
797.                 }
798.                 else if ( l == k )
799.                 {
800.                     /* 错误——没有找到入点！ */
801.                     printf( "error-can not find in point in edgeList/n" );
802.                 }
803.                 else
804.                 {
805.                     l++;
806.                 }
807.             }
808.             /* 从edgeList中找到了入点, 判断是否与起点相等 */
809.             if ( edgeList[l].x == curStart.x && edgeList[l].y == curStart.y )
810.             {
811.                 /* 与起点相等，哈哈~一个多边形区域被确定了！ */
812.                 clippedList[numClipped++] = edgeList[l];
813.                 /*printf(" DONE " );*/
814.                 break;
815.             }
816.             else
817.             {
818.                 clippedList[numClipped++] = edgeList[l];
819.                 /* 与起点不相等 */
820.                 /* 从polyList中找到与当前入点相同的点 */
821.                 for ( i = 0; polyList[i].x != edgeList[l].x || polyList[i].y != edgeList[l].y && i < numVector + numIntersect; i++ );
822.                 if ( i == numVector + numIntersect )
823.                 {
824.                     /* 错误——没有找到与edgeList中出点相对应的边缘点！ */
825.                     printf( "error-can not find out point in edgeList/n" );
826.                     return;
827.                 }
829.                 continue;
830.             }
831.         }
833.         /* 上面这个while循环确定一个多边形区域，接着绘制这份多边形区域 */
834.         setcolor( RED );
835.         setlinestyle( SOLID_LINE, 0, 3 );
836.         for ( i = 0; i < numClipped - 1; i++ )
837.         {
838.             line( clippedList[i].x, clippedList[i].y, clippedList[i + 1].x, clippedList[i + 1].y );
839.         }
841.         /*
842.         for ( i = 0; i < numClipped; i++ )
843.         {
844.             printf( "(%d,%d)", clippedList[i].x - PRIMITIVE_LEFT_TOP.x,clippedList[i].y - PRIMITIVE_LEFT_TOP.x );
845.         }
846.         printf("/n");
847.         */
849.         free( clippedList );
850.     }
852.     free( polyList );
853.     free( edgeList );
854. }
856. int main()
857. {
858.     int gdriver = VGA , gmode = VGAHI;
859.     Vector primitive[VECTOR_NUM + 1];
860.     int i = 0;
861.     char cmd = ' ';
863.     primitive[0].x = PRIMITIVE_LEFT_TOP.x + 35;
864.     primitive[0].y = PRIMITIVE_LEFT_TOP.y;
865.     primitive[1].x = PRIMITIVE_LEFT_TOP.x + 200;
866.     primitive[1].y = PRIMITIVE_LEFT_TOP.y + 60;
867.     primitive[2].x = PRIMITIVE_LEFT_TOP.x + 130;
868.     primitive[2].y = PRIMITIVE_LEFT_TOP.y + 140;
869.     primitive[3].x = PRIMITIVE_LEFT_TOP.x;
870.     primitive[3].y = PRIMITIVE_LEFT_TOP.y + 80;
871.     primitive[4].x = PRIMITIVE_LEFT_TOP.x + 60;
872.     primitive[4].y = PRIMITIVE_LEFT_TOP.y + 60;
873.     primitive[5].x = PRIMITIVE_LEFT_TOP.x + 60;
874.     primitive[5].y = PRIMITIVE_LEFT_TOP.y + 20;
875.     primitive[6].x = PRIMITIVE_LEFT_TOP.x + 40;
876.     primitive[6].y = PRIMITIVE_LEFT_TOP.y + 40;
877.     primitive[7] = primitive[0];
879.     initgraph (&gdriver , &gmode , "d://");
881.     while ( TRUE )
882.     {
883.         cleardevice();
884.         setcolor( WHITE );
886.         setlinestyle( SOLID_LINE, 0, 1 );
887.         for ( i = 0; i < VECTOR_NUM; i++ )
888.         {
889.             line( primitive[i].x, primitive[i].y, primitive[i + 1].x, primitive[i + 1].y );
890.         }
891.         setlinestyle( DOTTED_LINE, 0, 1 );
892.         rectangle( AREA_LEFT_TOP.x, AREA_LEFT_TOP.y, AREA_RIGHT_BOTTOM.x, AREA_RIGHT_BOTTOM.y );
894.         outtext( "Enter the key:" );
895.         outtextxy( 20, 10, "'1': Sutherland - Hodgeman Clipping." );
896.         outtextxy( 20, 20, "'2': Weiler - Atherton Clipping." );
897.         outtextxy( 20, 30, "'q': Quit." );
900.         cmd = getch();
901.         if ( cmd == '1' )
902.         {
903.             SingleEdgeClipping( primitive, VECTOR_NUM );
904.             getch();
905.         }
906.         else if ( cmd == '2' )
907.         {
908.             EdgeClipping( primitive, VECTOR_NUM );
909.             getch();
910.         }
911.         else if ( cmd == 'q' )
912.         {
913.             closegraph();
914.             return 0;
915.         }
916.     }
918.     /* should never be here */
919.     closegraph();
920.     return 0;
921. }