[OpenGL] 不规则区域的填充算法

不规则区域的填充算法

一、简单递归

利用Dfs实现简单递归填充。
核心代码：

 // 简单深度搜索填充 （四连通）
 void DfsFill(int x, int y)
 {
     if (x <  || y <  || x> || y>)
     {
         return;
     }
     if (a[x][y] == )
     {
         a[x][y] = ;
         DfsFill(x - , y);
         DfsFill(x + , y);
         DfsFill(x, y - );
         DfsFill(x, y + );
     }
 }

二、扫描线种子填充算法（四连通）

1. 种子点（x,y）入栈。
2. 栈顶元素（x,y）出栈作为种子点。
3. 从种子点（x,y）开始沿着扫描线向左右两个方向逐个像素进行填充，直到到达边界像素为止。
4. 将上述填充区段的左右端点的横坐标分别记为xleft和xright.
5. 在与当前扫描线相邻的上下两条扫描线的[xleft，xright]范围内进行检查，
看看是否全部为边界像素或已填充像素，若存在着非边界且未填充的像素，那么将该区段的最右端像素作为种子点入栈。

 // 扫描线种子填充算法（四连通）
 void ScanFill(int x, int y)
 {
     if (a[x][y]!=)
     {
         return;
     }
     Pos first(x, y);
     s.push(first);
     while (!s.empty())
     {
         int rightX = ;
         int leftX = ;
         Pos cur = s.top();
         s.pop();
         a[cur.x][cur.y] = ;
         // 遍历当前行
         for (int i = ; i < ; i++)
         {
             if (cur.x + i < )
             {
                 if (a[cur.x + i][cur.y] == )
                     a[cur.x + i][cur.y] = ;
                 else
                 {
                     rightX = cur.x + i - ;
                     break;
                 }
             }
             else
             {
                 rightX = ;
             }
         }
         for (int i = ; i < ; i++)
         {
             if (cur.x - i > -)
             {
                 if (a[cur.x - i][cur.y] == )
                     a[cur.x - i][cur.y] = ;
                 else
                 {
                     leftX = cur.x - i + ;
                     break;
                 }
             }
             else
             {
                 leftX = ;
             }
         }

         cout << leftX <<","<<rightX << endl;

         // 判断上行
         int upRightX = -;
         for (int i = leftX;i<=rightX;i++)
         {
             upRightX = -;
             if (a[i][cur.y+]== && cur.y+<)
             {
                 upRightX = i;
             }
             if (upRightX != -)
             {
                 Pos temPos(upRightX, cur.y + );
                 s.push(temPos);
             }
         }

         // 判断下行
         int downRightX = -;
         for (int i = leftX; i <= rightX; i++)
         {
             downRightX = -;
             if (a[i][cur.y - ] ==  && cur.y -  >=)
             {
                 downRightX = i;
             }
             if (downRightX != -)
             {
                 Pos temPos(downRightX, cur.y - );
                 s.push(temPos);
             }
         }

     }
 }

完整代码：

 #include <cmath>
 #include <stack>
 #include "gl/glut.h"
 #include "iostream"
 using namespace std;

 #define PI 3.14

 struct Pos
 {
     int x;
     int y;
     Pos(int mx, int my) :x(mx), y(my) {};
     Pos() :x(), y() {};
 };

 stack<Pos> s;
 int a[][] = {  };

 void init(void)
 {
     glClearColor(1.0, 1.0, 1.0, 1.0);
     glMatrixMode(GL_PROJECTION);//设置投影矩阵
     gluOrtho2D(0.0, 600.0, 0.0, 600.0);//二维视景区域
     glPointSize(12.0f);
 }
 // 画棋子
 void Drawtri(int x,int y,int color)
 {
     double n = ;//分段数
     float R = ;//半径
     int i;
     if (color == )
     {
         glColor3f(1.0, 0.0, 0.0);
     }
     else if (color == )
     {
         glColor3f(0.0, 1.0, 0.0);
     }
     glBegin(GL_POLYGON);
     glVertex2f(x, y);
     for (i = ; i <= n; i++)
         glVertex2f(R*cos( * PI / n * i)+x, R*sin( * PI / n * i)+y);
     glEnd();
     glPopMatrix();
 }

 // 绘制格线
 void playMap()
 {
     glColor3f(0.0, 0.0, 0.0);
     glBegin(GL_LINES);
     for (int i = ; i < ; i += )
     {
         glVertex2f(i, );
         glVertex2f(i, );
     }
     for (int j = ; j < ; j += )
     {
         glVertex2f(, j);
         glVertex2f(, j);
     }
     glEnd();
     for (int k = ; k < ; k++)
     {
         for (int l = ; l < ; l++)
         {
             if (a[k][l] == )
             {
                 Drawtri(k *  + , l *  + ,);
             }
             else if (a[k][l] == )
             {
                 Drawtri(k *  + , l *  + , );
             }
         }
     }
 }

 // 简单深度搜索填充 （四连通）
 void DfsFill(int x, int y)
 {
     if (x <  || y <  || x> || y>)
     {
         return;
     }
     if (a[x][y] == )
     {
         a[x][y] = ;
         DfsFill(x - , y);
         DfsFill(x + , y);
         DfsFill(x, y - );
         DfsFill(x, y + );
     }
 }

 // 扫描线种子填充算法（四连通）
 void ScanFill(int x, int y)
 {
     if (a[x][y]!=)
     {
         return;
     }
     Pos first(x, y);
     s.push(first);
     while (!s.empty())
     {
         int rightX = ;
         int leftX = ;
         Pos cur = s.top();
         s.pop();
         a[cur.x][cur.y] = ;
         // 遍历当前行
         for (int i = ; i < ; i++)
         {
             if (cur.x + i < )
             {
                 if (a[cur.x + i][cur.y] == )
                     a[cur.x + i][cur.y] = ;
                 else
                 {
                     rightX = cur.x + i - ;
                     break;
                 }
             }
             else
             {
                 rightX = ;
             }
         }
         for (int i = ; i < ; i++)
         {
             if (cur.x - i > -)
             {
                 if (a[cur.x - i][cur.y] == )
                     a[cur.x - i][cur.y] = ;
                 else
                 {
                     leftX = cur.x - i + ;
                     break;
                 }
             }
             else
             {
                 leftX = ;
             }
         }

         cout << leftX <<","<<rightX << endl;

         // 判断上行
         int upRightX = -;
         for (int i = leftX;i<=rightX;i++)
         {
             upRightX = -;
             if (a[i][cur.y+]== && cur.y+<)
             {
                 upRightX = i;
             }
             if (upRightX != -)
             {
                 Pos temPos(upRightX, cur.y + );
                 s.push(temPos);
             }
         }

         // 判断下行
         int downRightX = -;
         for (int i = leftX; i <= rightX; i++)
         {
             downRightX = -;
             if (a[i][cur.y - ] ==  && cur.y -  >=)
             {
                 downRightX = i;
             }
             if (downRightX != -)
             {
                 Pos temPos(downRightX, cur.y - );
                 s.push(temPos);
             }
         }

     }
 }

 void displayFcn(void)
 {
     glClear(GL_COLOR_BUFFER_BIT);
     playMap();
     glFlush();
 }

 void mouse(GLint button, GLint action, GLint x, GLint y)
 {
     int curX, curY;
     if (button == GLUT_LEFT_BUTTON && action == GLUT_DOWN)
     {
         curX = x / ;
         curY = ( - y) / ;
         a[curX][curY] = ;
         glutPostRedisplay();//重绘窗口
     }
     if (button == GLUT_RIGHT_BUTTON && action == GLUT_DOWN)
     {
         curX = x / ;
         curY = ( - y) / ;
         ScanFill(curX, curY);

         glutPostRedisplay();//重绘窗口
     }
 }

 void main(int argc, char** argv)
 {
     glutInit(&argc, argv);
     glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
     glutInitWindowPosition(, );
     glutInitWindowSize(, );
     glutCreateWindow("mouse");

     init();
     glutDisplayFunc(displayFcn);

     glutMouseFunc(mouse);

     glutMainLoop();

 }