opengl填充编程以及案例（机器人）种子填充、polygon

最新推荐文章于 2022-12-01 17:05:56 发布
最新推荐文章于 2022-12-01 17:05:56 发布
阅读量1k 收藏 23
点赞数 3
文章标签： opengl 图形学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45228525/article/details/106162920
版权

1.线框机器人：
在这里插入图片描述

#include <gl/glut.h>
#include <math.h> 
#define PI 3.1415926

//画矩形，传入的是左下角XY坐标和右上角XY坐标
void glRect(int leftX, int leftY, int rightX, int rightY) {
    //画封闭曲线
    glBegin(GL_LINE_LOOP);
    //左下角
    glVertex2d(leftX, leftY);
    //右下角
    glVertex2d(rightX, leftY);
    //右上角
    glVertex2d(rightX, rightY);
    //左上角
    glVertex2d(leftX, rightY);
    //结束画线
    glEnd();
}

//画圆角矩形，传入矩形宽高，角半径，矩形中心点坐标
void glRoundRec(int centerX, int centerY, int width, int height, float cirR)
{
    //计算内矩形宽高一半的数值
    int w = width / 2 - cirR;
    int h = height / 2 - cirR;

    //二分之PI，一个象限的角度
    float PI_HALF = PI / 2;
    //圆角矩形的坐标
    float tx, ty;
    //圆角弧度，ts开始弧度，te结束弧度，dt增加的弧度
    double t, ts, te;
    double dt = 1 / cirR;
    //四个象限，圆弧与w、h有不同操作，定义四个象限的操作操作符
    int opX[4] = { 1,-1,-1,1 };
    int opY[4] = { 1,1,-1,-1 };
    //画线
    glBegin(GL_LINE_LOOP);
    //用来计数，从第一象限到第四象限
    int x, y;
    for (x = 0; x < 4; x = x + 1)
    {
        ts = PI_HALF * x;
        te = PI_HALF * (x + 1);
        for (t = ts; t <= te; t += dt)
        {
            tx = cirR * cos(t) + opX[x] * w + centerX;
            ty = cirR * sin(t) + opY[x] * h + centerY;
            glVertex2f(tx, ty);
        }
    }
    glEnd();
}

//画弧线，相对偏移量XY，开始的弧度，结束的弧度，半径
void glArc(double x, double y, double start_angle, double end_angle, double radius)
{
    //开始绘制曲线
    glBegin(GL_LINE_STRIP);
    //每次画增加的弧度
    double delta_angle = PI / 180;
    //画圆弧
    for (double i = start_angle; i <= end_angle; i += delta_angle)
    {
        //绝对定位加三角函数值
        double vx = x + radius * cos(i);
        double vy = y + radius * sin(i);
        glVertex2d(vx, vy);
    }
    //结束绘画
    glEnd();
}


//画圆
void glCircle(double x, double y, double radius)
{
    //画全圆
    glArc(x, y, 0, 2 * PI, radius);
}

//画三角形，传入三个点的坐标
void glTri(int x1, int y1, int x2, int y2, int x3, int y3) {
    //画封闭线
    glBegin(GL_LINE_LOOP);
    //一点
    glVertex2d(x1, y1);
    //二点
    glVertex2d(x2, y2);
    //三点
    glVertex2d(x3, y3);
    //结束画线
    glEnd();
}

//画线，传入两点坐标
void glLine(int x1, int y1, int x2, int y2) {
    //画线
    glBegin(GL_LINES);
    //一点
    glVertex2d(x1, y1);
    //二点
    glVertex2d(x2, y2);
    //结束画线
    glEnd();
}

//函数用来画图
void display(void)
{
    //GL_COLOR_BUFFER_BIT表示清除颜色
    glClear(GL_COLOR_BUFFER_BIT);
    //设置画线颜色
    glColor3f(0.0, 0.0, 0.0);
    //设置画线宽度
    glLineWidth(2);

    //画圆角矩形，大肚子
    glRoundRec(0, 0, 146, 120, 15);
    //画圆角矩形，大脸
    glRoundRec(0, 113, 128, 74, 10);
    //圆角矩形，两个耳朵
    glRoundRec(81, 115, 20, 34, 5);
    glRoundRec(-81, 115, 20, 34, 5);
    //画圆角矩形，大长腿
    glRoundRec(-32, -92, 38, 52, 10);
    glRoundRec(32, -92, 38, 52, 10);

    //两个眼睛
    glCircle(-30, 111, 10);
    glCircle(30, 111, 10);
    //画圆形，手掌
    glCircle(-95, -47, 10);
    glCircle(95, -47, 10);
    //圆弧，画嘴
    glArc(0, 133, 11 * PI / 8, 13 * PI / 8, 45);

    //画矩形，脖子
    glRect(-25, 60, 25, 76);
    //画矩形，胳膊连接处
    glRect(-81, 43, -73, 25);
    glRect(81, 43, 73, 25);
    //画矩形，上臂
    glRect(-108, 45, -81, 0);
    glRect(108, 45, 81, 0);
    //画矩形，中臂
    glRect(-101, 0, -88, -4);
    glRect(101, 0, 88, -4);
    //画矩形，下臂
    glRect(-108, -4, -81, -37);
    glRect(108, -4, 81, -37);
    //画腿连接处
    glRect(-41, -62, -21, -66);
    glRect(41, -62, 21, -66);
    //画矩形，脚踝
    glRect(-41, -125, -21, -117);
    glRect(41, -125, 21, -117);
    //画矩形，大脚掌
    glRect(-59, -125, -8, -137);
    glRect(59, -125, 8, -137);

    //两条天线
    glLine(-35, 150, -35, 173);
    glLine(35, 150, 35, 173);


    //画三角，肚子里的三角
    glTri(-30, -15, 30, -15, 0, 28);
     //画圆，中间小圈
    glCircle(0, 0, 10);

    glFlush();
}


//窗口大小变化时调用的函数
void ChangeSize(GLsizei w, GLsizei h)
{
    //避免高度为0
    if (h == 0) {
        h = 1;
    }
    //定义视口大小，宽高一致  
    glViewport(0, 0, w, h);
    int half = 200;
    //重置坐标系统，使投影变换复位
    glMatrixMode(GL_PROJECTION);
    //将当前的用户坐标系的原点移到了屏幕中心
    glLoadIdentity();
    //定义正交视域体  
    if (w < h) {
        //如果高度大于宽度，则将高度视角扩大，图形显示居中
        glOrtho(-half, half, -half * h / w, half * h / w, -half, half);
    }
    else {
        //如果宽度大于高度，则将宽度视角扩大，图形显示居中
        glOrtho(-half * w / h, half * w / h, -half, half, -half, half);
    }

}

//程序入口
int main(int argc, char* argv[]) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);
    glutInitWindowPosition(100, 100);
    glutInitWindowSize(400, 400);
    glutCreateWindow("线框robot");
    glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
    glutDisplayFunc(&display);
    glutReshapeFunc(ChangeSize);
    glutMainLoop();
    return 0;
}

2.种子填充算法：
在这里插入图片描述

#include <glut.h>
#include <math.h> 
#include <stack>
using namespace std;
#define PI 3.1415926

struct Point
{
    int x;
    int y;
};

int halfWidth, halfHeight;
GLubyte iPixel[3];
GLubyte borderColor[3] = {0,0,0};

//传入两个颜色的RGB值，比较是否相同，容差为dis
bool sameColor(int r1, int g1, int b1, int r2, int g2, int b2) 
{
    //容差度
    int dis = 10;
    if (abs(r1 - r2) <= dis && abs(g1 - g2) <= dis && abs(b1 - b2) <= dis) {
        return true;
    }
    else {
        return false;
    }
}


//画点
void glPoint(int x, int y, int r, int g, int b) {
    glColor3ub(r, g, b);
    glPointSize(1);
    glBegin(GL_POINTS);
    glVertex2i(x, y);
    glEnd();
    glFlush();
}


//种子填充算法
void zzFill(int startX, int startY, int r, int g, int b) {
    stack<Point> pixelStack;
    //x,y是给定的种子像素点，rgb就是要填充的颜色的RGB值
    Point point = { startX,startY };
    pixelStack.push(point);
    int saveX;
    int xRight, xLeft;
    int x, y;
    //如果栈不为空
    while (!pixelStack.empty()) {
        //获取最顶端的元素
        Point tempPoint = pixelStack.top();
        //删除最顶端的元素
        pixelStack.pop();
        saveX = tempPoint.x;
        x = tempPoint.x;
        y = tempPoint.y;
        glReadPixels(x + halfWidth, y + halfHeight, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, &iPixel);
        //如果没有到达右边界，就填充
        while (!sameColor(iPixel[0], iPixel[1], iPixel[2], borderColor[0], borderColor[1], borderColor[2])) 
        {
            glPoint(x, y, r, g, b);
            x = x + 1;
            glReadPixels(x + halfWidth, y + halfHeight, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, &iPixel);
        }
        xRight = x - 1;
        x = saveX - 1;
        glReadPixels(x + halfWidth, y + halfWidth, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, &iPixel);
        //如果没有到达左边界，就填充
        while (!sameColor(iPixel[0], iPixel[1], iPixel[2], borderColor[0], borderColor[1], borderColor[2])) {
            glPoint(x, y, r, g, b);
            x = x - 1;
            glReadPixels(x + halfWidth, y + halfWidth, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, &iPixel);
        }
        //保存左端点
        xLeft = x + 1;
        //从右边的点开始
        x = xRight;
        //检查上端的扫描线
        y = y + 1;
        while (x >= xLeft) {
            glReadPixels(x + halfWidth, y + halfWidth, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, &iPixel);
            if (!sameColor(iPixel[0], iPixel[1], iPixel[2], borderColor[0], borderColor[1], borderColor[2]) && !sameColor(iPixel[0], iPixel[1], iPixel[2], r, g, b)) {
                //如果上方的点不是边界点，直接压入
                Point p = { x,y };
                pixelStack.push(p);
                //压入之后停止循环
                break;
            }
            else {
                x--;
                glReadPixels(x + halfWidth, y + halfWidth, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, &iPixel);
            }
        }
        //检查下端的扫描线
        y = y - 2;
        //从右边的点开始
        x = xRight;
        while (x >= xLeft) {
            glReadPixels(x + halfWidth, y + halfWidth, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, &iPixel);
            if (!sameColor(iPixel[0], iPixel[1], iPixel[2], borderColor[0], borderColor[1], borderColor[2]) && !sameColor(iPixel[0], iPixel[1], iPixel[2], r, g, b)) {
                //如果上方的点不是边界点，直接压入
                Point p = { x,y };
                //压入之后停止循环
                pixelStack.push(p);
                break;
            }
            else {
                x--;
                glReadPixels(x + halfWidth, y + halfWidth, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, &iPixel);
            }
        }
    }
}


//画矩形，传入的是左下角XY坐标和右上角XY坐标
void glRect(int leftX, int leftY, int rightX, int rightY) {
    //画封闭曲线
    glBegin(GL_LINE_LOOP);
    //左下角
    glVertex2d(leftX, leftY);
    //右下角
    glVertex2d(rightX, leftY);
    //右上角
    glVertex2d(rightX, rightY);
    //左上角
    glVertex2d(leftX, rightY);
    //结束画线
    glEnd();
}

//画圆角矩形，传入矩形宽高，角半径，矩形中心点坐标
void glRoundRec(int centerX, int centerY, int width, int height, float cirR)
{
    //计算内矩形宽高一半的数值
    int w = width / 2 - cirR;
    int h = height / 2 - cirR;

    //二分之PI，一个象限的角度
    float PI_HALF = PI / 2;
    //圆角矩形的坐标
    float tx, ty;
    //圆角弧度，ts开始弧度，te结束弧度，dt增加的弧度
    double t, ts, te;
    double dt = 1 / cirR;
    //四个象限，圆弧与w、h有不同操作，定义四个象限的操作操作符
    int opX[4] = { 1,-1,-1,1 };
    int opY[4] = { 1,1,-1,-1 };
    //画线
    glBegin(GL_LINE_LOOP);
    //用来计数，从第一象限到第四象限
    int x, y;
    for (x = 0; x < 4; x = x + 1)
    {
        ts = PI_HALF * x;
        te = PI_HALF * (x + 1);
        for (t = ts; t <= te; t += dt)
        {
            tx = cirR * cos(t) + opX[x] * w + centerX;
            ty = cirR * sin(t) + opY[x] * h + centerY;
            glVertex2f(tx, ty);
        }
    }
    glEnd();
}

//画弧线，相对偏移量XY，开始的弧度，结束的弧度，半径
void glArc(double x, double y, double start_angle, double end_angle, double radius)
{
    //开始绘制曲线
    glBegin(GL_LINE_STRIP);
    //每次画增加的弧度
    double delta_angle = PI / 180;
    //画圆弧
    for (double i = start_angle; i <= end_angle; i += delta_angle)
    {
        //绝对定位加三角函数值
        double vx = x + radius * cos(i);
        double vy = y + radius * sin(i);
        glVertex2d(vx, vy);
    }
    //结束绘画
    glEnd();
}


//画圆
void glCircle(double x, double y, double radius)
{
    //画全圆
    glArc(x, y, 0, 2 * PI, radius);
}

//画三角形，传入三个点的坐标
void glTri(int x1, int y1, int x2, int y2, int x3, int y3) {
    //画封闭线
    glBegin(GL_LINE_LOOP);
    //一点
    glVertex2d(x1, y1);
    //二点
    glVertex2d(x2, y2);
    //三点
    glVertex2d(x3, y3);
    //结束画线
    glEnd();
}

//画线，传入两点坐标
void glLine(int x1, int y1, int x2, int y2) {
    //画线
    glBegin(GL_LINES);
    //一点
    glVertex2d(x1, y1);
    //二点
    glVertex2d(x2, y2);
    //结束画线
    glEnd();
}

//函数用来画图
void display(void)
{
    //GL_COLOR_BUFFER_BIT表示清除颜色
    glClear(GL_COLOR_BUFFER_BIT);
    //设置画线颜色
    glColor3f(0.0, 0.0, 0.0);
    //设置画线宽度
    glLineWidth(2);

    //画圆角矩形，大肚子
    glRoundRec(0, 0, 146, 120, 15);
    //画圆角矩形，大脸
    glRoundRec(0, 113, 128, 74, 10);
    //圆角矩形，两个耳朵
    glRoundRec(81, 115, 20, 34, 5);
    glRoundRec(-81, 115, 20, 34, 5);
    //画圆角矩形，大长腿
    glRoundRec(-32, -92, 38, 52, 10);
    glRoundRec(32, -92, 38, 52, 10);

    //两个眼睛
    glCircle(-30, 111, 10);
    glCircle(30, 111, 10);
    //画圆形，手掌
    glCircle(-95, -47, 10);
    glCircle(95, -47, 10);
    //圆弧，画嘴
    glArc(0, 133, 11 * PI / 8, 13 * PI / 8, 45);

    //画矩形，脖子
    glRect(-25, 60, 25, 76);
    //画矩形，胳膊连接处
    glRect(-81, 43, -73, 25);
    glRect(81, 43, 73, 25);
    //画矩形，上臂
    glRect(-108, 45, -81, 0);
    glRect(108, 45, 81, 0);
    //画矩形，中臂
    glRect(-101, 0, -88, -4);
    glRect(101, 0, 88, -4);
    //画矩形，下臂
    glRect(-108, -4, -81, -37);
    glRect(108, -4, 81, -37);
    //画腿连接处
    glRect(-41, -62, -21, -66);
    glRect(41, -62, 21, -66);
    //画矩形，脚踝
    glRect(-41, -125, -21, -117);
    glRect(41, -125, 21, -117);
    //画矩形，大脚掌
    glRect(-59, -125, -8, -137);
    glRect(59, -125, 8, -137);

    //两条天线
    glLine(-35, 150, -35, 173);
    glLine(35, 150, 35, 173);


    //画三角，肚子里的三角
    glTri(-30, -15, 30, -15, 0, 28);
    //画圆，中间小圈
    glCircle(0, 0, 10);


    //灰色:195,195,195
    //黄色:255,243,0
    //红色:237,28,36
    //深灰色:126,126,126
    //脖子
    zzFill(0, 70, 195, 195, 195);
    //头
    zzFill(-50, 110, 195, 195, 195);
    zzFill(0, 93, 195, 195, 195);
    //肚子
    zzFill(-50, 0, 195, 195, 195);
    //耳朵
    zzFill(-80, 115, 126, 126, 126);
    zzFill(80, 115, 126, 126, 126);
    //肚子三角
    zzFill(-20, -10, 255, 243, 0);
    //肚子红色圆
    zzFill(0, 0, 237, 28, 36);
    //zzFill(-50,0,128,255,33);
    //大臂
    zzFill(-90, 30, 126, 126, 126);
    zzFill(90, 30, 126, 126, 126);
    //小臂
    zzFill(-90, -20, 126, 126, 126);
    zzFill(90, -20, 126, 126, 126);
    //手
    zzFill(-75, 40, 195, 195, 195);
    zzFill(75, 40, 195, 195, 195);
    //手
    zzFill(-95, -47, 195, 195, 195);
    zzFill(95, -47, 195, 195, 195);
    //大腿连接处
    zzFill(-40, -64, 195, 195, 195);
    zzFill(40, -64, 195, 195, 195);
    //大腿
    zzFill(-40, -100, 126, 126, 126);
    zzFill(40, -100, 126, 126, 126);
    //脚踝
    zzFill(-40, -121, 195, 195, 195);
    zzFill(40, -121, 195, 195, 195);
    //脚掌
    zzFill(-40, -130, 126, 126, 126);
    zzFill(40, -130, 126, 126, 126);
    system("pause");



    glFlush();
}


//窗口大小变化时调用的函数
void ChangeSize(GLsizei w, GLsizei h)
{
    //避免高度为0
    if (h == 0) {
        h = 1;
    }
    //定义视口大小，宽高一致  
    glViewport(0, 0, w, h);
    int half = 200;
    //重置坐标系统，使投影变换复位
    glMatrixMode(GL_PROJECTION);
    //将当前的用户坐标系的原点移到了屏幕中心
    glLoadIdentity();
    //定义正交视域体  
    if (w < h) {
        //如果高度大于宽度，则将高度视角扩大，图形显示居中
        glOrtho(-half, half, -half * h / w, half * h / w, -half, half);
    }
    else {
        //如果宽度大于高度，则将宽度视角扩大，图形显示居中
        glOrtho(-half * w / h, half * w / h, -half, half, -half, half);
    }

    halfWidth = w / 2;
    halfHeight = h / 2;

}

//程序入口
int main(int argc, char* argv[]) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);
    glutInitWindowPosition(100, 100);
    glutInitWindowSize(400, 400);
    glutCreateWindow("线框robot");
    glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
    glutDisplayFunc(&display);
    glutReshapeFunc(ChangeSize);
    glutMainLoop();
    return 0;
}

3.polygon算法:
在这里插入图片描述

#include <glut.h>
#include <math.h> 
#define PI 3.1415926

int border[3] = { 0,0,0 };
int grey[3] = { 195,195,195 };
int yellow[3] = { 255,243,0 };
int red[3] = { 237,28,36 };
int darkGrey[3] = { 126,126,126 };
int white[3] = { 255,255,255 };
int lineWidth = 2;

//画矩形，传入的是左下角XY坐标和右上角XY坐标
void glRect(int leftX, int leftY, int rightX, int rightY, int MODE)
{
    //画封闭曲线
    glBegin(MODE);
    //左下角
    glVertex2d(leftX, leftY);
    //右下角
    glVertex2d(rightX, leftY);
    //右上角
    glVertex2d(rightX, rightY);
    //左上角
    glVertex2d(leftX, rightY);
    //结束画线
    glEnd();
}

//画填充的矩形，传入左上角、右下角的坐标、填充的颜色
void glFillRect(int leftX, int leftY, int rightX, int rightY, int color[3])
{
    glColor3ub(border[0], border[1], border[2]);
    glRect(leftX, leftY, rightX, rightY, GL_LINE_LOOP);
    glColor3ub(color[0], color[1], color[2]);
    glRect(leftX, leftY, rightX, rightY, GL_POLYGON);
}

//画圆角矩形，传入矩形宽高，角半径，矩形中心点坐标
void glRoundRec(int centerX, int centerY, int width, int height, float cirR, int MODE)
{
    //计算内矩形宽高一半的数值
    int w = width / 2 - cirR;
    int h = height / 2 - cirR;

    //二分之PI，一个象限的角度
    float PI_HALF = PI / 2;
    //圆角矩形的坐标
    float tx, ty;
    //圆角弧度，ts开始弧度，te结束弧度，dt增加的弧度
    double t, ts, te;
    double dt = 1 / cirR;
    //四个象限，圆弧与w、h有不同操作，定义四个象限的操作操作符
    int opX[4] = { 1,-1,-1,1 };
    int opY[4] = { 1,1,-1,-1 };
    //画线
    glBegin(MODE);
    //用来计数，从第一象限到第四象限
    int x, y;
    for (x = 0; x < 4; x=x+1)
    {
        ts = PI_HALF * x;
        te = PI_HALF * (x + 1);
        for (t = ts; t <= te; t += dt)
        {
            tx = cirR * cos(t) + opX[x] * w + centerX;
            ty = cirR * sin(t) + opY[x] * h + centerY;
            glVertex2f(tx, ty);
        } 
    }
    glEnd();
}

//画填充的圆角矩形
void glFillRoundRec(int centerX, int centerY, int width, int height, float cirR, int color[3]) {
    glColor3ub(border[0], border[1], border[2]);
    glRoundRec(centerX, centerY, width, height, cirR, GL_LINE_LOOP);
    glColor3ub(color[0], color[1], color[2]);
    glRoundRec(centerX, centerY, width, height, cirR, GL_POLYGON);
}

//画弧线，相对偏移量XY，开始的弧度，结束的弧度，半径
void glArc(double x, double y, double start_angle, double end_angle, double radius, int MODE)
{
    //开始绘制曲线
    glBegin(MODE);
    //每次画增加的弧度
    double delta_angle = PI / 180;
    //画圆弧
    for (double i = start_angle; i <= end_angle; i += delta_angle)
    {
        //绝对定位加三角函数值
        double vx = x + radius * cos(i);
        double vy = y + radius * sin(i);
        glVertex2d(vx, vy);
    }
    //结束绘画
    glEnd();
}

//画圆
void glCircle(double x, double y, double radius, int MODE)
{
    //画全圆
    glArc(x, y, 0, 2 * PI, radius, MODE);
}

//画填充的圆形
void glFillCircle(double x, double y, double radius, int color[3])
{
    glColor3ub(border[0], border[1], border[2]);
    glCircle(x, y, radius, GL_LINE_LOOP);
    glColor3ub(color[0], color[1], color[2]);
    glCircle(x, y, radius, GL_POLYGON);
}

//画三角形，传入三个点的坐标
void glTri(int x1, int y1, int x2, int y2, int x3, int y3, int MODE)
{
    //画线
    glBegin(MODE);
    //一点
    glVertex2d(x1, y1);
    //二点
    glVertex2d(x2, y2);
    //三点
    glVertex2d(x3, y3);
    //结束画线
    glEnd();
}

//画填充的三角形
void glFillTri(int x1, int y1, int x2, int y2, int x3, int y3, int color[3]) {
    glColor3ub(border[0], border[1], border[2]);
    glTri(x1, y1, x2, y2, x3, y3, GL_LINE_LOOP);
    glColor3ub(color[0], color[1], color[2]);
    glTri(x1, y1, x2, y2, x3, y3, GL_POLYGON);
}

//画线，传入两点坐标
void glLine(int x1, int y1, int x2, int y2) {
    //画线
    glBegin(GL_LINES);
    //一点
    glVertex2d(x1, y1);
    //二点
    glVertex2d(x2, y2);
    //结束画线
    glEnd();
}

//函数用来画图
void display(void)
{
    //GL_COLOR_BUFFER_BIT表示清除颜色
    glClear(GL_COLOR_BUFFER_BIT);
    glLineWidth(lineWidth);

    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

    //画圆角矩形，大肚子
    glFillRoundRec(0, 0, 146, 120, 15, grey);
    //画圆角矩形，大脸
    glFillRoundRec(0, 113, 128, 74, 10, grey);
    //圆角矩形，两个耳朵
    glFillRoundRec(81, 115, 20, 34, 5, darkGrey);
    glFillRoundRec(-81, 115, 20, 34, 5, darkGrey);
    //画圆角矩形，大长腿
    glFillRoundRec(-32, -92, 38, 52, 10, darkGrey);
    glFillRoundRec(32, -92, 38, 52, 10, darkGrey);

    //两个眼睛
    glFillCircle(-30, 111, 10, white);
    glFillCircle(30, 111, 10, white);
    //画圆形，手掌
    glFillCircle(-95, -47, 10, grey);
    glFillCircle(95, -47, 10, grey);
    //圆弧，画嘴
    glColor3ub(border[0], border[1], border[2]);
    glArc(0, 133, 11 * PI / 8, 13 * PI / 8, 45, GL_LINE_STRIP);

    //画矩形，脖子
    glFillRect(-25, 76, 25, 60, grey);

    //画矩形，胳膊连接处
    glFillRect(-81, 43, -73, 25, grey);
    glFillRect(73, 43, 81, 25, grey);
    //画矩形，上臂
    glFillRect(-108, 45, -81, 0, darkGrey);
    glFillRect(81, 45, 108, 0, darkGrey);
    //画矩形，中臂
    glFillRect(-101, 0, -88, -4, grey);
    glFillRect(88, 0, 101, -4, grey);
    //画矩形，下臂
    glFillRect(-108, -4, -81, -37, darkGrey);
    glFillRect(81, -4, 108, -37, darkGrey);
    //画腿连接处
    glFillRect(-41, -62, -21, -66, grey);
    glFillRect(21, -62, 41, -66, grey);
    //画矩形，脚踝
    glFillRect(-41, -117, -21, -125, grey);
    glFillRect(21, -117, 41, -125, grey);
    //画矩形，大脚掌
    glFillRect(-59, -125, -8, -137, darkGrey);
    glFillRect(8, -125, 59, -137, darkGrey);

    //黑色线
    glColor3ub(0, 0, 0);
    //两条天线
    glLine(-35, 150, -35, 173);
    glLine(35, 150, 35, 173);

    //画三角，肚子里的三角
    glFillTri(-30, -15, 30, -15, 0, 28, yellow);

    //画圆，中间小圈
    glFillCircle(0, 0, 10, red);

    glFlush();
}


//窗口大小变化时调用的函数
void ChangeSize(GLsizei w, GLsizei h)
{
    //避免高度为0
    if (h == 0) {
        h = 1;
    }
    //定义视口大小，宽高一致  
    glViewport(0, 0, w, h);
    int half = 200;
    //重置坐标系统，使投影变换复位
    glMatrixMode(GL_PROJECTION);
    //将当前的用户坐标系的原点移到了屏幕中心
    glLoadIdentity();
    //定义正交视域体  
    if (w < h) {
        //如果高度大于宽度，则将高度视角扩大，图形显示居中
        glOrtho(-half, half, -half * h / w, half * h / w, -half, half);
    }
    else {
        //如果宽度大于高度，则将宽度视角扩大，图形显示居中
        glOrtho(-half * w / h, half * w / h, -half, half, -half, half);
    }
}

//程序入口
int main(int argc, char* argv[]) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);
    glutInitWindowPosition(100, 100);
    glutInitWindowSize(400, 400);
    glutCreateWindow("填充的robot");
    glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
    glutDisplayFunc(&display);
    glutReshapeFunc(ChangeSize);
    glutMainLoop();
    return 0;
}

以上是opengl的学习笔记 仅供参考哦

S_yeol
关注
  • 3
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Python 图形学 基于OpenGL图形的区域填充，种子递归算法
03-23
计算机图形学作业 单个py文件
vc6.0+opengl纯色五角星填充
03-29
OpenGL是一种强大的图形编程库，广泛应用于游戏开发、科学可视化、虚拟现实等领域。它提供了一组低级别的函数，允许程序员直接控制显卡硬件进行图形渲染。本教程将介绍如何在Microsoft Visual C++ 6.0（简称VC6.0）...
【计算机图形学 】多边形种子填充算法 | OpenGL+鼠标交互
Rover95的博客
10-21 4437
文章目录前言步骤1.点的结构体2.确定线的颜色3.设计画点函数（用于填充颜色的点）4.判断是否为边界的函数5. 扫描线算法实现用队列`queue`实现的 4连通区域的填充算法用栈实现的 扫描线形式的填充算法6. 鼠标响应事件完整代码 前言 实现多边形种子填充算法，分为四连通填充和扫描线填充，（分别由队列和栈实现的）并和鼠标进行交互。 具体原理略过，最后会贴上完整代码，可直接运行。 环境： vs2019,OpenGL的库（可以搜索如何用vs使用OpenGL的库，可以使用vs自带的插件或者其他方法，很方便） 要
高效率种子填充算法
AhCola
06-21 1040
高效率种子填充算法 文章同时发布于：http://pengfeixc.com/blog/60d06420e97367196dce3efb 最近写了一个画板小程序，为了实现画板的填充功能，研究了一下图形学填充算法。我在网上查找了大量的资料，最终找到了一个效率很高的填充算法。可以在minicode看到我的画板程序，测试下填充功能的速度。 下面我将讲述我的算法实现过程。 一. 种子填充算法（flood fill or seed fill） 网上有很多讲解种子填充算法的，大家一搜就知道有4联通的方式和8联通的方式。
计算机图形实验三 ：种子填充 python（堆栈实现法 和 递归实现法）动画
lei1321231236574的博客
12-01 1463
计算机图形实验三 多边形的种子填充算法
计算机图形学--种子填充算法原理及代码实现
emandora的博客
04-25 8136
种子填充思想 边界表示的种子填充 内点表示的种子填充 四连通扩展方式 八连通扩展方式 四连通vs八连通 代码实现 四连通--边界表示 四连通--内点表示 八连通--边界表示 八连通--内点表示
种子填充算法c语言代码实现,OpenGL绘图实例三之种子填充算法
weixin_32536777的博客
05-23 2169
综述博主研究了一下午加一晚上，终于把种子填充算法实现出来并把机器人填充完毕，路途很艰辛，不过也学到了很多，在此和大家一起分享。吐槽与我不是同学的小伙伴，请自动忽略，我是来吐槽教材的。 在此不得不吐槽一下，不得不说教材实在太坑爹了。对于种子填充算法的后半部分，下一个种子点的寻找过程中，从while(x<=xright)开始，我实在无法搞懂它里面的神逻辑，最初我认为它是对的，后来按照它的思路实现...
扫描线填充_opengl扫描线填充_
10-01
OpenGL是一种广泛应用于图形编程的开源图形库，它...代码可能包括顶点坐标定义、OpenGL环境设置、绘制多边形边框以及扫描线填充的实现。通过阅读和理解这段代码，你可以更好地掌握如何在OpenGL中使用扫描线填充技术。
OPenGL.zip_图案填充
09-14
在"OpenGL.zip_图案填充"这个主题中，我们将深入探讨如何利用OpenGL来填充多边形内部，形成具有各种图案的视觉效果。 图案填充是计算机图形学中的一个基本概念，它涉及到在多边形内部填充特定的纹理或颜色模式。在...
polygon.rar_matlab polygon_polygon_扫描线填充_矢量 文件_矢量线
07-15
典型的多边形填充算法主要包括扫描线填充算法和轮廓标志域填充算法,适用于矢量多边形文件的填充算法为扫描线填充算法
DuoBianXing.zip_多边形填充
09-21
`Graphics2D`对象提供了设置线条宽度、样式（实线、虚线等）以及填充模式的方法。 8. **刷新显示** - 当用户完成多边形定义或改变填充设置后，需要调用`repaint()`方法来刷新界面，展示最新的图形。 总结，...
扫描线填充算法的OpenGL实现
12-16
其中，扫描线填充算法是一种广泛应用的方法，尤其在OpenGL编程中。OpenGL是一个强大的跨语言、跨平台的图形库，常用于创建三维图像和应用程序。本篇文章将深入探讨基于AEL（活化边表）的扫描线填充算法在OpenGL中的...
Delphi Canvas 填充 区域 图形
10-01
在Delphi编程环境中，Canvas是TForm或...总的来说，这个项目通过Canvas展示了如何在Delphi中创建用户交互的图形界面，包括绘制和填充图形，以及响应用户事件。理解和掌握这些基础知识对于Delphi编程来说至关重要。
openGL不规则区域填充算法
05-07
总之，OpenGL不规则区域填充算法是图形编程中的一个重要主题，通过理解和实践，你可以创建出更加复杂的图形和交互式应用。在VC++环境下，结合OpenGL库，你可以深入理解这些概念，并掌握实际的编程技巧。
用vc6做的鼠标点击图形填充
06-25
在计算机图形学中，"用vc6做的鼠标点击图形填充"是一个常见的编程实践，它涉及到图形用户界面（GUI）的开发以及图形绘制技术。VC6，全称Microsoft Visual C++ 6.0，是微软发布的一款集成开发环境，广泛用于C++编程。...
种子填色(Seed Filling)算法
qq_41698119的博客
10-14 6979
种子填色(Seed Filling)算法 区域填充即给出一个区域的边界，要求对边界范围内的所有像素单元赋予指定的颜色代码。 区域填充中最常用的是多边形填色。 多边形填色即给出一个多边形的边界，要求对多边形边界范围内所有像素单元赋予指定的颜色代码。 填色算法分为两大类： ⒈ 扫描线填色(Scan-Line Filling)算法。 ⒉ 种子填色(Seed Filling)算法。 这里主要和...
计算机图形学E4——OpenGL 区域种子填充
duanyuchen的博客
09-07 1553
emmm好像没太理解老师的意思，或许就这么填充？ #include<GL/glut.h> void display() { glClear(GL_COLOR_BUFFER_BIT); glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); //glPolygonMode(GL_FRONT_AND_BACK, GL_POINT); glColor3...
【OpenGL】计算机图形学实验三: 区域填充算法实验(区域填充算法)
JKL27的博客
07-08 4161
(区域填充算法)1、实验目的和要求熟悉并掌握多边形区域用顺序扫描和种子填充算法原理，并利用数据结构和程序设计知识加以实现。2、实验设备PC机、CodeBlocks\VS系列\OpenGL安装包3、实验内容及原理 根据自己的兴趣选择1-2个作为本次实验的研究内容实验原理(基本知识)边标志填充算法：先用一种特殊的颜色在帧缓冲存储器中将多边形的边界（水平边部分的边界除外）勾画出来，然后将着色的像素点依x坐标递增的顺序两两配对，再将每对像素构成的扫描线区间内所有像素置为填充色。4、实验源程序代码、运行结果4.1边标
OpenGL入门教程
Lce的专栏
10-02 8556
一维纹理定义一个一维纹理映射，除了第一个参数target应设置为GL_TEXTURE_1D外，其余所有的参数与函数TexImage2D()的一致，不过纹理图像是一维纹素数组，其宽度值必须是2的幂，若有边界则为2m+2。二维纹理定义一个二维纹理映射。其中参数target是常数GL_TEXTURE_2D。参数level表示多级分辨率的纹理图像的级数，若只有一种分辨率，则level设为0。
BM.polygon 填充颜色改为填充图片
最新发布
05-10
要将BM.Polygon的填充颜色更改为填充图像，您可以使用以下步骤： 1. 导入PIL库： ```python from PIL import Image ``` 2. 加载要用作填充的图像： ```python img = Image.open("path/to/image.jpg") ``` 3. 将...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值