c++ - 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 位 unsigned int 和 DWORD 是 32 位 unsigned int ...一些编译器和语言不再有它，所以如果情况使用您拥有的或通过 typedef 创建它 ...

   您甚至可以移植您的 BGI 代码(由于您缺乏格式化，我乍一看忽略了 bfill 实现)只需编写 putpixel和 getpixel 函数与 GL 对应项。并删除 延迟 !!!例如:

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

   OpenGL 可以原生且快速地渲染带有填充的此类形状。只需渲染为 glBegin(GL_POLYGON)/glEnd() 或 triangulate并改用 GL_TRIANGLE(如剪耳)。

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

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