区域填充：扫描线种子填充和剖面线填充

1. #include "stdio.h"
2. #include "graphics.h"
3. #include "malloc.h"
4. #include "conio.h"
5. #include "math.h"
7. /*******************************扫描线种子填充*********************/
8. #define LEFT 200
9. #define TOP 200
11. #define TRUE 1
12. #define FALSE 0
14. #define BOUND WHITE
16. #define DELAYTIME 10000
18. typedef struct
19. {
20.     int x;
21.     int y;
22. } Data;
24. typedef struct _Node
25. {
26.     Data data;
27.     struct _Node *next;
28. } Node, *List;
30. typedef struct _Stack
31. {
32.     Node *top;
33. } Stack;
35. /* 初始化栈 */
36. void Init( Stack *s )
37. {
38.     s->top = NULL;
39. }
41. /* 入栈 */
42. void Push( Stack *s, Data d )
43. {
44.     Node *newN = ( Node * )malloc( sizeof( Node ) );
45.     newN->data.x = d.x;
46.     newN->data.y = d.y;
47.     newN->next = s->top;
48.     s->top = newN;
50.     /*printf("Push %d, %d to Stack/n", s->top->data.x, s->top->data.y );*/
51. }
53. /* 出栈 */
54. Data Pop( Stack *s )
55. {
56.     Node *toPop = s->top;
57.     Data d = toPop->data;
58.     s->top = s->top->next;
59.     free (toPop);
61.     /*printf("Pop %d, %d from Stack/n", d.x, d.y );*/
62.     /*printf("p:%d,%d ", d.x-LEFT, d.y-TOP);*/
64.     return d;
65. }
67. /* 检测栈是否为空 */
68. int Empty( Stack *s )
69. {
70.     if ( s->top == NULL )
71.     {
72.         return TRUE;
73.     }
74.     else
75.     {
76.         return FALSE;
77.     }
78. }
79.   
80. Data GetTop( Stack *s )
81. {
82.     if ( Empty( s ) != 0 )
83.     {
84.         return s->top->data;
85.     }
86. }
88. /* 扫描线种子填充 */
89. void SeedFill( int seedX, int seedY, int color )
90. {
91.     Data seed, newSeed;
92.     int xLeft, xRight, xCurrent, yCurrent;
93.     int needFill = FALSE;
94.     Stack seedStack;
96.     Init( &seedStack );
98.     seed.x = seedX;
99.     seed.y = seedY;
100.     /* 种子入栈 */
101.     Push( &seedStack, seed );
103.     while ( Empty( &seedStack ) == FALSE )
104.     {
105.         /* 种子出栈并给点上色 */
106.         seed = Pop( &seedStack );
107.         putpixel( seed.x, seed.y, color );
109.         /* 填充当前扫描线位于种子左边的部分 */
110.         xCurrent = seed.x - 1;
111.         yCurrent = seed.y;
112.         while ( getpixel( xCurrent, yCurrent ) != color &
113.                 getpixel( xCurrent, yCurrent ) != BOUND )
114.         {
115.             putpixel( xCurrent, yCurrent, color );
116.             xCurrent -= 1;
117.         }
118.         /* 记录最左侧的内点 */
119.         xLeft = xCurrent + 1;
121.         /* 填充当前扫描线位于种子右边的部分 */
122.         xCurrent = seed.x + 1;
123.         yCurrent = seed.y;
124.         while ( getpixel( xCurrent, yCurrent ) != color &
125.                 getpixel( xCurrent, yCurrent ) != BOUND )
126.         {
127.             putpixel( xCurrent, yCurrent, color );
128.             xCurrent += 1;
129.         }
130.         /* 记录最右侧的内点 */
131.         xRight = xCurrent - 1;
133.         /*printf("left: %d, %d 's color is %d/n", xLeft, yCurrent, getpixel(xLeft, xRight));*/
135.         /* 上移一条扫描线*/
136.         yCurrent = seed.y - 1;
137.         xCurrent = xLeft;
138.         /* 从左向右检测非边界、未填充的象素 */
139.         while ( xCurrent < xRight )
140.         {
141.             while ( getpixel( xCurrent, yCurrent ) != color &
142.                     getpixel( xCurrent, yCurrent ) != BOUND )
143.             {
144.                 /* 存在未填充的像素，则需要填充 */
145.                 needFill = TRUE;
146.                 xCurrent += 1;
147.             }
148.             /* 最右侧像素入栈 */
149.             if ( needFill == TRUE )
150.             {
151.                 newSeed.x = xCurrent - 1;
152.                 newSeed.y = yCurrent;
153.                 Push( &seedStack, newSeed );
154.                 needFill = FALSE;
156.                 break;
157.             }
158.             xCurrent++;
159.         }
160.         delay(DELAYTIME);
162.         needFill = FALSE;
163.         /* 下移一条扫描线 */
164.         yCurrent = seed.y + 1;
165.         xCurrent = xLeft;
166.         /* 从左向右检测非边界、未填充的象素 */
167.         while ( xCurrent < xRight )
168.         {
169.             while ( getpixel( xCurrent, yCurrent ) != color &
170.                     getpixel( xCurrent, yCurrent ) != BOUND )
171.             {
172.                 /* 存在未填充的像素，则需要填充 */
173.                 needFill = TRUE;
174.                 xCurrent += 1;
175.             }
176.             /* 最右侧像素入栈 */
177.             if ( needFill == TRUE )
178.             {
179.                 newSeed.x = xCurrent - 1;
180.                 newSeed.y = yCurrent;
181.                 Push( &seedStack, newSeed );
182.                 needFill = FALSE;
184.                 break;
185.             }
186.             xCurrent++;
187.         }
188.         delay(DELAYTIME);
189.     }
190. }
191. /*********************End of 扫描线种子填充*********************************/
193. /**********************************剖面线种子填充******************************/
194. #define BIG_PLUS_INT 65534
196. #define K -1.0f
197. #define DELTA_B 5.0f
199. /* 顶点 */
200. typedef struct _Vector
201. {
202.     int x, y;
203. } Vector;
205. /* 边 */              
206. typedef struct _Edge
207. {
208.     Vector v1, v2;  
209. } Edge;
211. /******************************************************
212. * summery
213. *   求得剖面线的画线范围和总数，求得各条边的可相交范围
214. * in
215. *   e[] - 边信息
216. *   numEdge - 图元的边数
217. *   k - 剖面线的斜率
218. *   bDelta - 相邻两条剖面线的距离
219. * inout
220. *   bMinMax[] - 剖面线的画线范围
221. *   edgeMinMax[][2] - 各条边的可相交范围
222. * out
223. *   int - 剖面线的画线总数
224. *******************************************************/    
225. int CalcPrimitiveInfo( Edge e[], int numEdge, float k, float bDelta, float bMinMax[], float edgeMinMax[][2] )
226. {
227.     int i;
228.     float tempF;
229.     float bMin = BIG_PLUS_INT, bMax = -BIG_PLUS_INT;
230.     int numHatching;
231.                                                                                             
232.     for ( i = 0; i < numEdge; i++ )
233.     {
234.         edgeMinMax[i][0] = e[i].v1.y - k * e[i].v1.x;
235.         edgeMinMax[i][1] = e[i].v2.y - k * e[i].v2.x;
236.         if ( edgeMinMax[i][0] > edgeMinMax[i][1] )
237.         {
238.             /* 交换 */
239.             tempF = edgeMinMax[i][0];
240.             edgeMinMax[i][0] = edgeMinMax[i][1];
241.             edgeMinMax[i][1] = tempF;
242.         }
243.         if ( edgeMinMax[i][0] < bMin )
244.         {
245.             /* 替换Min */
246.             bMin = edgeMinMax[i][0];
247.         }
248.         if ( edgeMinMax[i][1] > bMax )
249.         {
250.             /* 替换Max */
251.             bMax = edgeMinMax[i][1];
252.         }  
253.     }
254.     
255.     bMinMax[0] = bMin;
256.     bMinMax[1] = bMax;
257.     numHatching = ( bMax - bMin ) / bDelta;
258.     return numHatching;
259. }
261. /******************************************************
262. * summery
263. *   计算剖面线和边的交点
264. * in
265. *   e - 边信息
266. *   k - 剖面线的斜率
267. *   b - 当前剖面线的b值
268. * out
269. *   *point - 交点
270. *******************************************************/
271. void CalcIntersectPoint( Edge e, float k, float b, Vector *point)
272. {
273.     float m, n, t;
274.     m = e.v1.x * e.v2.y - e.v1.y * e.v2.x + b * ( e.v2.x - e.v1.x );
275.     n = e.v2.y - e.v1.y - k * ( e.v2.x - e.v1.x );
276.     t = m / n;
277.     point->x = floor( t + 0.5f );
278.     point->y = floor( k * t + b + 0.5f );
279. }
281. /******************************************************
282. * summery
283. *   对交点按照交点的x值进行排序
284. * inout
285. *   points[] - 交点数组
286. * in
287. *   numPoints - 交点总数
288. *******************************************************/
289. void SortPoints( Vector points[], int numPoints )
290. {
291.     int i, j;
292.     int tempX, tempY;
293.     for ( i = 1; i <= numPoints - 1; i++ )
294.     {
295.         for ( j = 0; j < numPoints - i; j++ )
296.         {
297.             if ( points[j].x > points[j + 1].x )
298.             {
299.                 /* 交换points[j]和points[j + 1] */
300.                 tempX = points[j].x;
301.                 tempY = points[j].y;
302.                 points[j].x = points[j + 1].x;
303.                 points[j].y = points[j + 1].y;
304.                 points[j + 1].x = tempX;
305.                 points[j + 1].y = tempY;
306.             }
307.         }
308.     }   
309. }
311. /******************************************************
312. * summery
313. *   画剖面线
314. * in
315. *   e[] - 边信息
316. *   numEdge - 图元的边数
317. *   k - 剖面线的斜率
318. *   bDelta - 相邻两条剖面线的距离
319. *   edgeMinMax[][2] - 各条边的可相交范围
320. * out
321. *   int - 剖面线的画线总数
322. *******************************************************/
323. void DrawHatching( Edge e[], int numEdges, float bMinMax[], float edgeMinMax[][2], float k, float b )
324. {
325.     int i, j, n = 0, nRealSectP = 0;
326.     Vector *points = ( Vector* )malloc( numEdges * sizeof( Vector ) ); /* 一条剖面线与边的交点总数不可能超过边的总数 */
327.     Vector v[2];
328.     int numPoints = 0;
329.     if ( b <= bMinMax[0] || b >= bMinMax[1] )
330.     {
331.         return;
332.     }
333.     
334.     /* 计算剖面线与所有边的交点 */
335.     for ( i = 0; i < numEdges; i++ )
336.     {
337.         if ( b >= edgeMinMax[i][0] && b <= edgeMinMax[i][1] )
338.         {
339.             /* 求交点 */
340.             CalcIntersectPoint( e[i], k, b, &( points[numPoints] ) );
341.             numPoints++; 
342.         }
343.     }
344.     
345.     /* 对这些交点进行排序 */
346.     SortPoints( points, numPoints );
347.     
348.     /* 绘制剖面线 */
349.     i = 0;
350.     nRealSectP = 0;
351.     while ( i < numPoints - 1 )
352.     {
353.         /*printf("i:%d, n:%d;", i, nRealSectP );*/
354.         /* 有重合的点 */
355.         if ( points[i].x == points[i + 1].x )
356.         {
357.             /* 找出共享该顶点的两条边的另外两个顶点 */
358.             n = 0;
359.             for ( j = 0; j < numEdges; j++ )
360.             {
361.                 if ( e[j].v1.x == points[i].x && e[j].v1.y == points[i].y )
362.                 {
363.                     v[n] = e[j].v2;
364.                     n++;
365.                 }
366.                 if ( e[j].v2.x == points[i].x && e[j].v2.y == points[i].y )
367.                 {
368.                     v[n] = e[j].v1;
369.                     n++;
370.                 }
371.                 if ( n >= 2 )
372.                 {
373.                     break;
374.                 }
375.             }
376.             /* 判断这两个顶点在剖面线的同侧还是异侧 */
377.             if ( ( v[0].y - k * v[0].x - b ) * ( v[1].y - k * v[1].x - b ) > 0 )
378.             {
379.                 /* 在同侧，计两个交点，故nRealSectP需要再加一 */
380.                 nRealSectP++;
381.             }
382.             else
383.             {
384.                 /* 在异侧，计一个交点,故nRealSectP不需要改变 */
385.             }
386.         }
387.         else
388.         {
389.             if ( nRealSectP % 2 == 0 )
390.             {                                      
391.                 line( points[i].x, points[i].y, points[i + 1].x, points[i + 1].y );
392.             }
393.             nRealSectP++;
394.         }
395.         i++;
396.     }
398.     free( points );
399. } 
400. /*************************End of 剖面线填充************************************/
402. int main()
403. {
404.     int gdriver = VGA , gmode = VGAHI;
405.     int polyPoints[6][2];
406.     char cmd;
407.     int i;
409.     Vector v[9];
410.     Edge e[9];
411.     float bMinMax[2];
412.     float edgeMinMax[9][2];
413.     int numHatching;
414.     float bCurrent;
416.     initgraph ( &gdriver , &gmode , "d://" );
418.     polyPoints[0][0] = 5 + LEFT;
419.     polyPoints[0][1] = 20 + TOP;
420.     polyPoints[1][0] = 35 + LEFT;
421.     polyPoints[1][1] = 0 + TOP;
422.     polyPoints[2][0] = 65 + LEFT;
423.     polyPoints[2][1] = 20 + TOP;
424.     polyPoints[3][0] = 85 + LEFT;
425.     polyPoints[3][1] = 70 + TOP;
426.     polyPoints[4][0] = 0 + LEFT;
427.     polyPoints[4][1] = 70 + TOP;
428.     polyPoints[5][0] = 5 + LEFT;
429.     polyPoints[5][1] = 20 + TOP;
431.     v[0].x = polyPoints[0][0];
432.     v[0].y = polyPoints[0][1];
433.     v[1].x = polyPoints[1][0];
434.     v[1].y = polyPoints[1][1];
435.     v[2].x = polyPoints[2][0];
436.     v[2].y = polyPoints[2][1];
437.     v[3].x = polyPoints[3][0];
438.     v[3].y = polyPoints[3][1];
439.     v[4].x = polyPoints[4][0];
440.     v[4].y = polyPoints[4][1];
441.     v[5].x = 15 + LEFT;
442.     v[5].y = 20 + TOP;
443.     v[6].x = 55 + LEFT;
444.     v[6].y = 20 + TOP;
445.     v[7].x = 55 + LEFT;
446.     v[7].y = 40 + TOP;
447.     v[8].x = 15 + LEFT;
448.     v[8].y = 40 + TOP;
450.     e[0].v1 = v[0];
451.     e[0].v2 = v[1];
452.     e[1].v1 = v[1];
453.     e[1].v2 = v[2];
454.     e[2].v1 = v[2];
455.     e[2].v2 = v[3];
456.     e[3].v1 = v[3];
457.     e[3].v2 = v[4];
458.     e[4].v1 = v[4];
459.     e[4].v2 = v[0];
460.     e[5].v1 = v[5];
461.     e[5].v2 = v[6];
462.     e[6].v1 = v[6];
463.     e[6].v2 = v[7];
464.     e[7].v1 = v[7];
465.     e[7].v2 = v[8];
466.     e[8].v1 = v[8];
467.     e[8].v2 = v[5];
469.     while ( TRUE )
470.     {
471.         cleardevice();
473.         outtext( "Enter the key:" );
474.         outtextxy( 20, 10, "'1': Fill with scanning line." );
475.         outtextxy( 20, 20, "'2': Fill with hatching." );
476.         outtextxy( 20, 30, "'q': Quit." );
478.         setcolor( BOUND );
479.         drawpoly( 6, *polyPoints );
480.         rectangle( v[5].x, v[5].y, v[7].x, v[7].y );
482.         cmd = getch();
483.         if ( cmd == '1' )
484.         {
485.             SeedFill( LEFT + 35, TOP + 60, BLUE );
486.             getch();
487.         }
488.         else if ( cmd == '2' )
489.         {
490.             numHatching = CalcPrimitiveInfo( e, 9, K, DELTA_B, bMinMax, edgeMinMax );
491.             for ( i = 1; i <= numHatching; i++ )
492.             {
493.                 bCurrent = bMinMax[0] + DELTA_B * i;
494.                 DrawHatching( e, 9, bMinMax, edgeMinMax, K, bCurrent );
496.                 delay( DELAYTIME );
497.             }
498.             getch();
499.         }
500.         else if ( cmd == 'q' )
501.         {
502.             closegraph();
503.             return 1;
504.         }
505.     }
507.     /* should never be here */
508.     getch();
509.     closegraph () ;
510. }