opengl c ++中的边界填充算法

Question

我如何使用opengl和c++实现边界填充算法我在网上搜索并找到了这段代码

  #include <iostream.h>
#include <conio.h>
#include <graphics.h>
#include <dos.h> void bfill(int x,int y,int fill,int border)
{
    if((getpixel(x,y)!=border)&&(getpixel(x,y)!=fill))
    {
        delay(8);
        putpixel(x,y,fill);

        bfill(x+1, y,fill,border);
            bfill(x, y+1,fill,border);
            bfill(x-1, y,fill,border);
            bfill(x, y-1,fill,border);          
    }
}
void main()
{
    int gd=DETECT,gm;
    initgraph(&gd,&gm,"C:\\Tc\\BGI");
    rectangle(10,50,50,10);
    bfill(11,12,MAGENTA,WHITE);
    getch();

但它正在使用 BGI 有人可以帮忙吗？

这是我的代码：

#include <windows.h> // Header file for Windows
#include <gl/gl.h> // Header file for the OpenGL Library
#include <gl/glu.h> // Header file for the GLu32 Library
#include <gl/glut.h>

#include<iostream>
#include<cmath>



using namespace std;

void draw_XOY(){
glBegin(GL_LINES);
//xox'
glVertex2d(-1000, 0);
glVertex2d(1000, 0);
//yoy'
glVertex2d(0, -1000);
glVertex2d(0, 1000);
glEnd();
}


void dda_line(int x1, int y1, int x2, int y2){
cout<<"Draw Line from "<<"("<<x1<<" , "<<y1<<")"<< " To "<<"("<<x2<<" , "<<y2<<")"<<endl;
float x,y,dx,dy,step;
int i;

glBegin(GL_LINE_STRIP);

dx=x2-x1;
dy=y2-y1;

if(dx>=dy)
step=dx;
else
step=dy;

dx=dx/step;
dy=dy/step;

x=x1;
y=y1;

i=1;
while(i<=step)
{
glVertex2d(x,y);
x=x+dx;
y=y+dy;
i=i+1;
}

glEnd();

cout<<endl<<endl;
}


void draw_up_ellipse(int a, int b, int k, int h){
int x = 0;
int y = 0;

float pi = 3.14121324;

glBegin(GL_POINTS);
for(float i = 0; i <= pi; i+=0.01){
x = a * cos(i) ;
y = b * sin(i) ;
cout<<x<<", "<<y<<endl;
glVertex2d(x+k, y+h);
}
glEnd();
}


void draw_down_ellipse(int a, int b, int k, int h){
int x = 0;
int y = 0;

float pi = 3.14121324;

glBegin(GL_POINTS);
for(float i = pi; i <= 2*pi; i+=0.01){
x = a * cos(i) ;
y = b * sin(i) ;
cout<<x<<", "<<y<<endl;
glVertex2d(x+k, y+h);
}
glEnd();
}


// draw function
static void redraw(void);

//main function
int main(int argc, char **argv)
{
glutInit(&argc,argv); // init the window with args
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH); //determine display MODE
glutInitWindowPosition(0,0); //the position of window
glutInitWindowSize(1200,1200); // size w X h
glutCreateWindow("First Example"); // create the window with this title
glutDisplayFunc(redraw); // draw function (contains al drawing stmts.)

glMatrixMode(GL_PROJECTION); // eye = camera look position and 'theta'
gluPerspective(45,1.0,0.1,1000.0); // theta, w/h , near, far
glMatrixMode(GL_MODELVIEW); //return to model view matrix

glutMainLoop(); // re-run
return 0; //return 0
}

// implementation of draw function
static void redraw(void)
{
glClearColor(0.0, 0.0, 0.0, 1.0); // determine clear color
glClearDepth(1.0); // depth clearaty
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // real clear
glLoadIdentity(); // load all init of I (eye to (0,0,0) )

glColor3f(0.0, 0.0, 1.0); // color of drawing geometries
glTranslatef(0.0f,0.0f,-200.0f); // all to back (( to see result))
glColor3f(1.0, 1.0, 1.0); // ???

//pixel size
glPointSize(3);
glLineWidth(2);

draw_XOY();

glColor3f(0.0, 1.0, 0.0);

dda_line(20, 10, 30, 20);
dda_line(30, 20, 40, 10);
dda_line(35, 0, 40, 10);
dda_line(25, 0, 35, 0);
dda_line(25, 0, 20, 10);
dda_line(20, 10, 35, 0);
dda_line(20, 10, 40, 10);
dda_line(35, 0, 30, 20);
dda_line(25, 0, 30, 20);
dda_line(25, 0, 40, 10);



glTranslated(-30,40,0);

glColor3f(1.0, 0.0, 0.0);
dda_line(-40, 0, -30, 0);
dda_line(-30, 0, -20, 0);
dda_line(-20, 0, -10, 0);
dda_line(-10, 0, 0, 0);

glColor3f(1.0, 1.0, 0.0);

draw_up_ellipse(10,8,-10,0);
draw_up_ellipse(15,13,-15,0);
draw_down_ellipse(15,8,-5,0);
draw_down_ellipse(20,13,0,0);

draw_up_ellipse(20,18,-10,0);
draw_up_ellipse(15,13,-15,0);
draw_down_ellipse(30,23,0,0);

draw_up_ellipse(30,23,-10,0);
draw_up_ellipse(35,28,-5,0);

glutSwapBuffers(); // to show frame in back buffer( no noise)
}

我需要填充这个（左边的形状）：

Answer 1

你有两个选择：

1. 实现边界填充

   但这不是 OpenGL 的工作方式，因此它会很慢（使用 glReadPixels 读取单个像素），除非您将屏幕复制到 CPU 端内存（使用单个 glReadPixels 调用）填充在 CPU 端（SW 渲染）那里，然后复制回屏幕（单纹理 QUAD 覆盖屏幕）。欲了解更多信息，请参阅：

   • my C++ implementation of Flood&Boundary fill

   只需忽略 VCL 的东西（无论如何填充都不会使用它）并将像素数组DWORD **pixel=NULL; 转换为您的像素格式。顺便说一句，在后面使用线性一维数组将在稍后简化纹理内容。这是读取整个屏幕并将其写回的方法：

   • OpenGL Scale Single Pixel Line

   要读取单个像素，您可以这样做：

   BYTE color[3];
   glReadPixels(x,y,1,1,GL_RGB,GL_UNSIGNED_BYTE,color);
   

   如果你不知道BYTE/DWORD 是什么（并称你自己是程序员）BYTE 是 8 位无符号整数，DWORD 是 32 位无符号整数......某些编译器和语言没有它不再，所以如果案例使用您拥有的或通过typedef 创建它...

   您甚至可以移植您的 BGI 代码（由于您缺乏格式，我乍一看忽略了 bfill 实现）只需编写 putpixel 和 getpixel 函数与 GL 对应。并删除delay ！！！例如：

2. 将您的形状转换为凸多边形并进行渲染

   OpenGL 可以通过本机快速填充来渲染此类形状。只需渲染为glBegin(GL_POLYGON)/glEnd() 或triangulate 并改用GL_TRIANGLE（如剪耳）。

   因此，不是逐个像素地渲染椭圆弧，而是将它们存储到 CPU 侧内存中的点列表中。三角剖分或重新排序为凸多边形，然后在glBegin/glEnd 内使用for 循环进行渲染（或使用VBO 和glDraw）...

   因此，您还需要将弧线的方向添加到您的函数和一些目标点列表中。