头哥多边形填充v1.0

最新推荐文章于 2024-01-24 23:58:19 发布
最新推荐文章于 2024-01-24 23:58:19 发布
阅读量180 收藏 2
点赞数
文章标签： 算法 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64210684/article/details/134696585
版权

第1关：扫描线填充算法（活动边表AET法

// 评测代码所用头文件-开始

#include<opencv2/core/core.hpp>

#include<opencv2/highgui/highgui.hpp>

#include<opencv2/imgproc/imgproc.hpp>

// 评测代码所用头文件-结束

#include<GL/freeglut.h>

#include<math.h>

#include<string>

#include <iostream>

using namespace std;

const int POINTNUM = 5;

typedef struct XET {

    int x;

    int dx, ymax;

    struct XET* next;

}AET, NET;

struct Point {

    int x;

    int y;

    Point() {}

    Point(int x, int y) {

        this->x = x;

        this->y = y;

    }

}polypoint[POINTNUM];

int MaxY, MinY;//多边形顶点沿Y轴的最小值和最大值

void Init(){

    polypoint[0] = Point(100,100);

    polypoint[1] = Point(100,300);

    polypoint[2] = Point(200,200);

    polypoint[3] = Point(300,300);

    polypoint[4] = Point(300,100);

    MaxY = polypoint[0].y;

    MinY = polypoint[0].y;

    for (int i = 0; i < POINTNUM; i++) {

        if (polypoint[i].y > MaxY) {

            MaxY = polypoint[i].y;

        }

        if (polypoint[i].y < MinY) {

            MinY = polypoint[i].y;

        }

    }

}

void PolyScan() {

    glBegin(GL_POINTS);

    glColor3f(0.0, 1.0, 0.0);//设置颜色的函数

    // 请在此添加你的代码

   /********** Begin ********/

    AET* pAET = new AET;

    pAET->next = NULL;

    NET* pNET[1024];

    for (int i = MinY; i <= MaxY; i++) {

        pNET[i] = new NET;

        pNET[i]->next = NULL;

    }

    //填NET表

    for (int i = MinY; i <= MaxY; i++)

    {

        for (int j = 0; j < POINTNUM; j++)

        {

            if (polypoint[j].y == i)

            {

                if (polypoint[(j - 1 + POINTNUM) % POINTNUM].y > polypoint[j].y) //左边的点

                {

                    NET* p = new NET;

                    p->x = polypoint[j].x;

                    p->ymax = polypoint[(j - 1 + POINTNUM) % POINTNUM].y;

                    p->dx = (polypoint[(j - 1 + POINTNUM) % POINTNUM].x - polypoint[j].x) / (polypoint[(j - 1 + POINTNUM) % POINTNUM].y - polypoint[j].y);

                    p->next = pNET[i]->next;

                    pNET[i]->next = p;

                }

                if (polypoint[(j + 1 + POINTNUM) % POINTNUM].y > polypoint[j].y)  //右边的点

                {

                    NET* p = new NET;

                    p->x = polypoint[j].x;

                    p->ymax = polypoint[(j + 1 + POINTNUM) % POINTNUM].y;

                    p->dx = (polypoint[(j + 1 + POINTNUM) % POINTNUM].x - polypoint[j].x) / (polypoint[(j + 1 + POINTNUM) % POINTNUM].y - polypoint[j].y);

                    p->next = pNET[i]->next;

                    pNET[i]->next = p;

                }

            }

        }

    }

    //建立更新AET

    for (int i = MinY; i <= MaxY; i++) {

        //计算新的交点x，更新AET

        NET* p = pAET->next;

        while (p != NULL)

        {

            p->x = p->x + p->dx;

            p = p->next;

        }

        //更新后新AET先排序

        //断表排序,不再开辟空间

        AET* tq = pAET;

        p = pAET->next;

        tq->next = NULL;

        while (p != NULL)  //按x排序

        {

            while (tq->next != NULL && p->x >= tq->next->x)

            {

                tq = tq->next;

            }

            NET* s = p->next;

            p->next = tq->next;

            tq->next = p;

            p = s;

            tq = pAET;

        }

        AET* q = pAET;

        p = q->next;

        while (p != NULL)

        {

            if (p->ymax == i)

            {

                q->next = p->next;

                delete p;

                p = q->next;

            }

            else

            {

                q = q->next;

                p = q->next;

            }

        }

        //将NET中的新点加入AET,并用插入法按X值递增排序

        p = pNET[i]->next;

        q = pAET;

        while (p != NULL)

        {

            while (q->next != NULL && p->x >= q->next->x)

            {

                q = q->next;

            }

            NET* s = p->next;

            p->next = q->next;

            q->next = p;

            p = s;

            q = pAET;

        }

        p = pAET->next;

        while (p && p->next)

        {

            for (float j = p->x; j <= p->next->x; j++)

                glVertex2f(j, i);

            p = p->next->next;//考虑端点情况

        }

    }

    NET* phead = NULL;

    NET* pnext = NULL;

    //释放活跃边表

    phead = pAET;

    while (phead != NULL)

    {

        pnext = phead->next;

        delete phead;

        phead = pnext;

    }



 

   /********** End **********/

    glEnd();

}

void LineGL(int i){

    glBegin(GL_LINES);

    glColor3f(0.0f, 1.0f, 0.0f);

    glVertex2f(polypoint[i].x, polypoint[i].y);

    glVertex2f(polypoint[i + 1].x, polypoint[i + 1].y);

    if (i == POINTNUM - 2) {

        glVertex2f(polypoint[0].x, polypoint[0].y);

        glVertex2f(polypoint[i + 1].x, polypoint[i + 1].y);

    }

    glEnd();

}

void MyDisplay()

{

    glClear(GL_COLOR_BUFFER_BIT);

    glColor3f(1.0f, 1.0f, 1.0f);

    for (int i = 0; i < POINTNUM - 1; i++) {

        LineGL(i);

    }

   PolyScan();

   glFlush();

}

void MyReshape(int w, int h)

{

    glViewport(0, 0, (GLsizei)w, (GLsizei)h);

    glMatrixMode(GL_PROJECTION);

    glLoadIdentity();

    gluOrtho2D(0.0, (GLdouble)w, 0.0, (GLdouble)h);

}

int main(int argc, char* argv[])

{

    glutInit(&argc, argv);//窗口的初始化

    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);//窗口谋模式的设定

    glutInitWindowPosition(100, 100);//窗口位置的设定

    glutInitWindowSize(400, 400);//窗口大小的设定

    glutCreateWindow("多边形的扫描填充");

    Init();

    glutDisplayFunc(MyDisplay);

    glutReshapeFunc(MyReshape);

    glutMainLoopEvent();

    /*************以下为评测代码，与本次实验内容无关，请勿修改**************/

    GLubyte* pPixelData = (GLubyte*)malloc(400 * 400 * 3);//分配内存

    GLint viewport[4] = {0};    

    glReadBuffer(GL_FRONT);

    glPixelStorei(GL_UNPACK_ALIGNMENT, 4);

    glGetIntegerv(GL_VIEWPORT, viewport);

    glReadPixels(viewport[0], viewport[1], viewport[2], viewport[3], GL_RGB, GL_UNSIGNED_BYTE, pPixelData);

    cv::Mat img;

    std::vector<cv::Mat> imgPlanes;

    img.create(400, 400, CV_8UC3);

    cv::split(img, imgPlanes);

    for(int i = 0; i < 400; i ++) {

        unsigned char* plane0Ptr = imgPlanes[0].ptr<unsigned char>(i);

        unsigned char* plane1Ptr = imgPlanes[1].ptr<unsigned char>(i);

        unsigned char* plane2Ptr = imgPlanes[2].ptr<unsigned char>(i);

        for(int j = 0; j < 400; j ++) {

            int k = 3 * (i * 400 + j);

            plane2Ptr[j] = pPixelData[k];

            plane1Ptr[j] = pPixelData[k+1];

            plane0Ptr[j] = pPixelData[k+2];

        }

    }

    cv::merge(imgPlanes, img);

    cv::flip(img, img ,0);

    cv::namedWindow("openglGrab");

    cv::imshow("openglGrab", img);

    cv::imwrite("../img_step1/test.jpg", img);

    return 0;

}


 

第2关：边缘填充法

// 评测代码所用头文件-开始

#include<opencv2/core/core.hpp>

#include<opencv2/highgui/highgui.hpp>

#include<opencv2/imgproc/imgproc.hpp>

// 评测代码所用头文件-结束

// 提示：写完代码请保存之后再进行评测

#include<GL/freeglut.h>

#include<math.h>

#include<string>

#include <iostream>

using namespace std;

const int POINTNUM = 5;

struct Point {

    int x;

    int y;

    Point() {}

    Point(int x, int y) {

        this->x = x;

        this->y = y;

    }

}polypoint[POINTNUM];

int MaxY, MinY;//多边形顶点沿Y轴的最小值和最大值

int vis[400][400];//判断该坐标的点是否为填充色，0为背景色，1为填充色

void Init() {

    polypoint[0] = Point(100, 100);

    polypoint[1] = Point(100, 300);

    polypoint[2] = Point(200, 200);

    polypoint[3] = Point(300, 300);

    polypoint[4] = Point(300, 100);

}

void EdgeFilling() {

    // 请在此添加你的代码

   /********** Begin ********/

int i, j, x, y, t;

    float k;

    for (i = 0; i < POINTNUM; i++) {

        if (i == 0)

            t = POINTNUM - 1;

        else

            t = i - 1;

        if (polypoint[t].y <= polypoint[i].y) {

            MinY = polypoint[t].y;

            MaxY = polypoint[i].y;

            j = polypoint[t].x;

            if (polypoint[t].x == polypoint[i].x) {

                k = 0;

            }

            else

                k = (float)(polypoint[i].y - polypoint[t].y) / (float)(polypoint[i].x - polypoint[t].x);

        }

        else {

            MinY = polypoint[i].y;

            MaxY = polypoint[t].y;

            j = polypoint[i].x;

            if (polypoint[t].x == polypoint[i].x) {

                k = 0;

            }

            else

                k = (float)(polypoint[t].y - polypoint[i].y) / (float)(polypoint[t].x - polypoint[i].x);

        }

        for (y = MinY; y < MaxY; y++) {

            for (x = j; x < 400; x++) {

                if (vis[x][y] == 1)

                    vis[x][y] = 0;

                else

                    vis[x][y] = 1;

            }

            j += k ;

        }

    }



 

   /********** End **********/

    glBegin(GL_POINTS);

    glColor3f(0.0, 1.0, 0.0);//设置颜色的函数

    for (int x = 0; x < 400; x++) {

        for (int y = 0; y < 400; y++) {

            if (vis[x][y] == 1) {

                glVertex2f(x, y);

            }

        }

    }

    glEnd();

}

void LineGL(int i){

    glBegin(GL_LINES);

    glColor3f(0.0f, 1.0f, 0.0f);

    glVertex2f(polypoint[i].x, polypoint[i].y);

    glVertex2f(polypoint[i + 1].x, polypoint[i + 1].y);

    if (i == POINTNUM - 2) {

        glVertex2f(polypoint[0].x, polypoint[0].y);

        glVertex2f(polypoint[i + 1].x, polypoint[i + 1].y);

    }

    glEnd();

}

void MyDisplay()

{

    glClear(GL_COLOR_BUFFER_BIT);

    glColor3f(1.0f, 1.0f, 1.0f);

    for (int i = 0; i < POINTNUM - 1; i++) {

        LineGL(i);

    }

   EdgeFilling();

    glFlush();

}

void MyReshape(int w, int h)

{

    glViewport(0, 0, (GLsizei)w, (GLsizei)h);

    glMatrixMode(GL_PROJECTION);

    glLoadIdentity();

    gluOrtho2D(0.0, (GLdouble)w, 0.0, (GLdouble)h);

}

int main(int argc, char* argv[])

{

    glutInit(&argc, argv);//窗口的初始化

    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);//窗口谋模式的设定

    glutInitWindowPosition(100, 100);//窗口位置的设定

    glutInitWindowSize(400, 400);//窗口大小的设定

    glutCreateWindow("多边形的扫描填充");

    Init();

    glutDisplayFunc(MyDisplay);//调用函数

    glutReshapeFunc(MyReshape);

    glutMainLoopEvent();

    /*************以下为评测代码，与本次实验内容无关，请勿修改**************/

    GLubyte* pPixelData = (GLubyte*)malloc(400 * 400 * 3);//分配内存

    GLint viewport[4] = {0};    

    glReadBuffer(GL_FRONT);

    glPixelStorei(GL_UNPACK_ALIGNMENT, 4);

    glGetIntegerv(GL_VIEWPORT, viewport);

    glReadPixels(viewport[0], viewport[1], viewport[2], viewport[3], GL_RGB, GL_UNSIGNED_BYTE, pPixelData);

    cv::Mat img;

    std::vector<cv::Mat> imgPlanes;

    img.create(400, 400, CV_8UC3);

    cv::split(img, imgPlanes);

    for(int i = 0; i < 400; i ++) {

        unsigned char* plane0Ptr = imgPlanes[0].ptr<unsigned char>(i);

        unsigned char* plane1Ptr = imgPlanes[1].ptr<unsigned char>(i);

        unsigned char* plane2Ptr = imgPlanes[2].ptr<unsigned char>(i);

        for(int j = 0; j < 400; j ++) {

            int k = 3 * (i * 400 + j);

            plane2Ptr[j] = pPixelData[k];

            plane1Ptr[j] = pPixelData[k+1];

            plane0Ptr[j] = pPixelData[k+2];

        }

    }

    cv::merge(imgPlanes, img);

    cv::flip(img, img ,0);

    cv::namedWindow("openglGrab");

    cv::imshow("openglGrab", img);

    cv::imwrite("../img_step2/test.jpg", img);

    return 0;

}

第3关：区域四连通种子填充算法

// 评测代码所用头文件-开始

#include<opencv2/core/core.hpp>

#include<opencv2/highgui/highgui.hpp>

#include<opencv2/imgproc/imgproc.hpp>

// 评测代码所用头文件-结束

// 提示：写完代码请保存之后再进行评测

#include<GL/freeglut.h>

#include<math.h>

#include<string>

#include <iostream>

using namespace std;

const int POINTNUM = 5;

struct Point {

    int x;

    int y;

    Point() {}

    Point(int x, int y) {

        this->x = x;

        this->y = y;

    }

}polypoint[POINTNUM];

int MaxY, MinY;//多边形顶点沿Y轴的最小值和最大值

int vis[400][400];//判断该坐标的点是否为填充色，0为背景色，1为填充色

void Init() {

    polypoint[0] = Point(100, 100);

    polypoint[1] = Point(100, 300);

    polypoint[2] = Point(200, 200);

    polypoint[3] = Point(300, 300);

    polypoint[4] = Point(300, 100);

}

void BoundaryFill4(int x, int y) {  

    // 请在此添加你的代码

   /********** Begin ********/

 if (vis[x][y] == 0) {

        glVertex2f(x, y);

        vis[x][y] = 1;

        BoundaryFill4(x - 1, y);

        BoundaryFill4(x + 1, y);

        BoundaryFill4(x, y - 1);

        BoundaryFill4(x, y + 1);

    }



 

   /********** End **********/

}

void BoundaryPoly() {

    int i, t, k, x, y;

    for (i = 0; i < POINTNUM; i++) {

        i == 0 ? t = POINTNUM - 1 : t = i - 1;

        if (polypoint[i].y >= polypoint[t].y) {

            MinY = polypoint[t].y;

            MaxY = polypoint[i].y;

            x = polypoint[t].x;

            if (polypoint[t].x == polypoint[i].x) {

                k = 0;

            }

            else

                k = (float)(polypoint[i].y - polypoint[t].y) / (float)(polypoint[i].x - polypoint[t].x);

        }

        else

        {

            MinY = polypoint[i].y;

            MaxY = polypoint[t].y;

            x = polypoint[i].x;

            if (polypoint[t].x == polypoint[i].x) {

                k = 0;

            }

            else

                k = (float)(polypoint[t].y - polypoint[i].y) / (float)(polypoint[t].x - polypoint[i].x);

        }

        for (y = MinY; y < MaxY; y++) {

            glVertex2f(x, y);

            vis[x][y] = 1;

            x += k;

        }

        if (polypoint[t].y == polypoint[i].y && polypoint[i].x > polypoint[t].x) {

            for (x = polypoint[t].x; x < polypoint[i].x; x++) {

                glVertex2f(x, polypoint[t].y);

                vis[x][y] = 1;

            }

        }

        else if (polypoint[t].y == polypoint[i].y && polypoint[i].x < polypoint[t].x) {

            for (x = polypoint[i].x; x < polypoint[t].x; x++) {

                glVertex2f(x, polypoint[t].y);

                vis[x][y] = 1;

            }

        }

    }

}

void MyDisplay()

{

    glClear(GL_COLOR_BUFFER_BIT);

    glColor3f(1.0f, 1.0f, 1.0f);

    glBegin(GL_POINTS);

    glColor3f(0.0, 1.0, 0.0);//设置颜色的函数

    //将边界用像素表示并输出；

    BoundaryPoly();

    BoundaryFill4(200, 150);

    glEnd();

    glFlush();

}

void MyReshape(int w, int h)

{

    glViewport(0, 0, (GLsizei)w, (GLsizei)h);

    glMatrixMode(GL_PROJECTION);

    glLoadIdentity();

    gluOrtho2D(0.0, (GLdouble)w, 0.0, (GLdouble)h);

}

int main(int argc, char* argv[])

{

    glutInit(&argc, argv);//窗口的初始化

    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);//窗口谋模式的设定

    glutInitWindowPosition(100, 100);//窗口位置的设定

    glutInitWindowSize(400, 400);//窗口大小的设定

    glutCreateWindow("多边形的扫描填充");

    Init();

    glutDisplayFunc(MyDisplay);//调用函数

    glutReshapeFunc(MyReshape);

    glutMainLoopEvent();


 

    /*************以下为评测代码，与本次实验内容无关，请勿修改**************/

    GLubyte* pPixelData = (GLubyte*)malloc(400 * 400 * 3);//分配内存

    GLint viewport[4] = {0};    

    glReadBuffer(GL_FRONT);

    glPixelStorei(GL_UNPACK_ALIGNMENT, 4);

    glGetIntegerv(GL_VIEWPORT, viewport);

    glReadPixels(viewport[0], viewport[1], viewport[2], viewport[3], GL_RGB, GL_UNSIGNED_BYTE, pPixelData);

    cv::Mat img;

    std::vector<cv::Mat> imgPlanes;

    img.create(400, 400, CV_8UC3);

    cv::split(img, imgPlanes);

    for(int i = 0; i < 400; i ++) {

        unsigned char* plane0Ptr = imgPlanes[0].ptr<unsigned char>(i);

        unsigned char* plane1Ptr = imgPlanes[1].ptr<unsigned char>(i);

        unsigned char* plane2Ptr = imgPlanes[2].ptr<unsigned char>(i);

        for(int j = 0; j < 400; j ++) {

            int k = 3 * (i * 400 + j);

            plane2Ptr[j] = pPixelData[k];

            plane1Ptr[j] = pPixelData[k+1];

            plane0Ptr[j] = pPixelData[k+2];

        }

    }

    cv::merge(imgPlanes, img);

    cv::flip(img, img ,0);

    cv::namedWindow("openglGrab");

    cv::imshow("openglGrab", img);

    cv::imwrite("../img_step3/test.jpg", img);

    return 0;

}

第4关：区域扫描线种子填充算法

// 评测代码所用头文件-结束// 提示：写完代码请保存之后再进行评测

#include<opencv2/core/core.hpp>

#include<opencv2/highgui/highgui.hpp>

#include<opencv2/imgproc/imgproc.hpp>

// 评测代码所用头文件-开始

#include<GL/freeglut.h>

#include<math.h>

#include<string>

#include <iostream>

#include<stack>

using namespace std;

const int POINTNUM = 5;

struct Point {

    int x;

    int y;

    Point() {}

    Point(int x, int y) {

        this->x = x;

        this->y = y;

    }

}polypoint[POINTNUM];

int MaxY, MinY;//多边形顶点沿Y轴的最小值和最大值

int vis[400][400];//判断该坐标的点是否为填充色，0为背景色，1为填充色

void Init() {

    polypoint[0] = Point(100, 100);

    polypoint[1] = Point(100, 300);

    polypoint[2] = Point(200, 200);

    polypoint[3] = Point(300, 300);

    polypoint[4] = Point(300, 100);

}

void FindNewSeed(stack<Point>& s,int left,int right,int y) {

   // 请在此添加你的代码

   /********** Begin ********/

for (int i = left + 1; i < right; i++) {

        if (vis[i][y] == 0) {

            int j = i + 1;

            while (vis[j][y] == 0)

                j++;

            i = j--;

            s.push(Point(j, y));

        }

    }



 

   /********** End **********/

}

void ScanLineFlood(int x, int y) {

    // 请在此添加你的代码

   /********** Begin ********/

stack<Point> s;

    Point p;

    int left, right;

    s.push(Point(x, y));

    while (!s.empty()) {

        //栈顶元素出栈

        p = s.top();

        s.pop();

        //向左填充

        for (left = p.x; vis[left][p.y] != 1; left--) {

            glVertex2f(left, p.y);

            vis[left][p.y] = 1;

        }  

        //向右填充

        for (right = p.x + 1; vis[right][p.y] != 1; right++) {

            glVertex2f(right, p.y);

            vis[right][p.y] = 1;

        }

        //在当前行的下一行寻找确定新的种子点

        FindNewSeed(s, left, right, p.y - 1);

        //在当前行的上一行寻找确定新的种子点

        FindNewSeed(s, left, right, p.y + 1);

    }



 

   /********** End **********/

}

void BoundaryPoly() {

    int i, t, k, x, y;

    for (i = 0; i < POINTNUM; i++) {

        i == 0 ? t = POINTNUM - 1 : t = i - 1;

        if (polypoint[i].y >= polypoint[t].y) {

            MinY = polypoint[t].y;

            MaxY = polypoint[i].y;

            x = polypoint[t].x;

            if (polypoint[t].x == polypoint[i].x) {

                k = 0;

            }

            else

                k = (float)(polypoint[i].y - polypoint[t].y) / (float)(polypoint[i].x - polypoint[t].x);

        }

        else

        {

            MinY = polypoint[i].y;

            MaxY = polypoint[t].y;

            x = polypoint[i].x;

            if (polypoint[t].x == polypoint[i].x) {

                k = 0;

            }

            else

                k = (float)(polypoint[t].y - polypoint[i].y) / (float)(polypoint[t].x - polypoint[i].x);

        }

        for (y = MinY; y < MaxY; y++) {

            glVertex2f(x, y);

            vis[x][y] = 1;

            x += k;

        }

        if (polypoint[t].y == polypoint[i].y && polypoint[i].x > polypoint[t].x) {

            for (x = polypoint[t].x; x < polypoint[i].x; x++) {

                glVertex2f(x, polypoint[t].y);

                vis[x][y] = 1;

            }

        }

        else if (polypoint[t].y == polypoint[i].y && polypoint[i].x < polypoint[t].x) {

            for (x = polypoint[i].x; x < polypoint[t].x; x++) {

                glVertex2f(x, polypoint[t].y);

                vis[x][y] = 1;

            }

        }

    }

}

void MyDisplay()

{

    glClear(GL_COLOR_BUFFER_BIT);

    glColor3f(1.0f, 1.0f, 1.0f);

    glBegin(GL_POINTS);

    glColor3f(0.0, 1.0, 0.0);//设置颜色的函数

    //将边界用像素表示并输出；

    BoundaryPoly();

    ScanLineFlood(200, 150);

    glEnd();

    glFlush();

}

void MyReshape(int w, int h)

{

    glViewport(0, 0, (GLsizei)w, (GLsizei)h);

    glMatrixMode(GL_PROJECTION);

    glLoadIdentity();

    gluOrtho2D(0.0, (GLdouble)w, 0.0, (GLdouble)h);

}

int main(int argc, char* argv[])

{

    glutInit(&argc, argv);//窗口的初始化

    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);//窗口谋模式的设定

    glutInitWindowPosition(100, 100);//窗口位置的设定

    glutInitWindowSize(400, 400);//窗口大小的设定

    glutCreateWindow("多边形的扫描填充");

    Init();

    glutDisplayFunc(MyDisplay);//调用函数

    glutReshapeFunc(MyReshape);

    glutMainLoopEvent();

    /*************以下为评测代码，与本次实验内容无关，请勿修改**************/

    GLubyte* pPixelData = (GLubyte*)malloc(400 * 400 * 3);//分配内存

    GLint viewport[4] = {0};

    glReadBuffer(GL_FRONT);

    glPixelStorei(GL_UNPACK_ALIGNMENT, 4);

    glGetIntegerv(GL_VIEWPORT, viewport);

    glReadPixels(viewport[0], viewport[1], viewport[2], viewport[3], GL_RGB, GL_UNSIGNED_BYTE, pPixelData);

     cv::Mat img;

    std::vector<cv::Mat> imgPlanes;

    img.create(400, 400, CV_8UC3);

    cv::split(img, imgPlanes);

        for(int i = 0; i < 400; i ++) {

            unsigned char* plane0Ptr = imgPlanes[0].ptr<unsigned char>(i);

            unsigned char* plane1Ptr = imgPlanes[1].ptr<unsigned char>(i);

            unsigned char* plane2Ptr = imgPlanes[2].ptr<unsigned char>(i);

            for(int j = 0; j < 400; j ++) {

                int k = 3 * (i * 400 + j);

                plane2Ptr[j] = pPixelData[k];

                plane1Ptr[j] = pPixelData[k+1];

                plane0Ptr[j] = pPixelData[k+2];

            }

        }

        cv::merge(imgPlanes, img);

        cv::flip(img, img ,0);

        cv::namedWindow("openglGrab");

        cv::imshow("openglGrab", img);

        //cv::waitKey();

        cv::imwrite("../img_step4/test.jpg", img);

    return 0;

}

weixin_64210684
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
实验三计算机图形学多边形填充算法.doc
04-10
实验三计算机图形学多边形填充算法
图形学实验MFC，种子填充算法，逐点，有序边，
11-23
第一步：点击button选择想要的算法。第二步：点击确认开始绘图。第三步：鼠标单击输入任意多边形的点，双击鼠标左键结束输入绘图完成
图形学实验之多边形填充算法
gaojie8075的专栏
11-03 2507
一、建立工程   二、设计交互界面   三、算法学习与实现 1、逐点扫描算法           原理很简单，逐点判断每一个像素是否在多边形内部，如果在这填充；   代码如下： void CcgGJFillView::Draw_Algorithm_everyPoint(CDC* pDC,COLORREF rgb) {  CPoint testPoint ;  for (te
头哥 （Educoder）数据结构与算法实验：实验11 TYJ动态规划
fanso12345的博客
07-31 1964
List item
计算机图形学：多边形填充算法（算法原理及代码实现）
qq_55982881的博客
02-22 1万+
一、实现方案 扫描线算法： 实现原理： 把图形的填充转换为扫描线从上往下扫描填充，这时我们只需要判断每一条扫描线与图形的交点，而我们可以根据扫描线的连贯性，对交点进行排序，第1个点与第2个点之间，第3个点与第4个点之间..... 依照此原理可以对图形进行扫描线算法扫描转换多边形，其中在判断上述交点时，还会出现扫描线与边重合、扫描线与边的交点为顶点等现象，具体实现步骤如下。 实现步骤： 1、找到多边形的最大Ymax和最小Ymin，在此范围内扫描多边形逐条； 2、一条扫描...
数字媒体技术计算机图形学vc++实验2：多边形边缘填充
m0_62316271的博客
05-08 796
vc++真是太好玩啦
【头歌 计算机图形学 练习】多边形填充v1.0 (第1关：扫描线填充算法（活动边表AET法） 第2关：边缘填充法 第3关：区域四连通种子填充算法 第4关：区域扫描线种子填充算法)
进一步有一步的欢喜
11-23 1391
【头歌 计算机图形学 练习】多边形填充v1.0 (第1关：扫描线填充算法（活动边表AET法） 第2关：边缘填充法 第3关：区域四连通种子填充算法 第4关：区域扫描线种子填充算法)
算法系列之十二：多边形区域填充算法－－扫描线填充算法（有序边表法）
java开发指南博客 【转载】
03-19 6230
二、扫描线算法（Scan-Line Filling） 扫描线算法适合对矢量图形进行区域填充，只需要直到多边形区域的几何位置，不需要指定种子点，适合计算机自动进行图形处理的场合使用，比如电脑游戏和三维CAD软件的渲染等等。 对矢量多边形区域填充，算法核心还是求交。《计算几何与图形学有关的几种常用算法》一文给出了判断点与多边形关系的算法――扫描交点的奇偶数判断算法，利用此算法可以判断一个点是否在多...
多边形填充 | 计算机图形学（c++版MFC）
kndjg的博客
06-04 3967
多边形填充 | 计算机图形学（c++版MFC） 直接上代码，不墨迹！！！
计算机图形学 第4章 多边形填充
CSDN_YJX的博客
01-30 8627
边缘填充算法是先求出多边形的每条边与扫描线的交点，然后将交点。
画多边形Winform程序 v1.0
10-07
一款C#编写的多边形制作Winform程序。
DuoBianXing.zip_多边形填充
09-21
java编写的简单的多边形填充的小程序，拥有简单界面可通过鼠标描点并绘制多边形、还可以进行填充。
c#实现多边形填充
03-16
c#多边形填充源码实例，其中LCDEmulator_SE目录内的是程序要用到的一个控件的源码。 　本C#多边形图形填充程序分为矢量填充和位图填充（区域填充）。矢量填充用的是扫描线算法，区域填充也是一种扫描线算法（而不是...
不同方式的多边形填充.rar_填充多边形_多边形_多边形填充
09-24
不同方式的多边形填充
头哥试题 实验三 循环结构程序设计（Python）
最新发布
Joeeeem的博客
01-24 1035
第一关打印图形，第二关斐波那契数列，第三关投资年限计算，第四关销售统计，第五关显示输入数字之内的完全数，第六关输出九九乘法表，第七关鸡兔同笼问题，第八关剩余最短木料，
计组头哥实验 实验五 汉字字库存储芯片扩展
gdz0007的博客
06-21 8618
理解存储系统进行位扩展、字扩展的基本原理，能利用相关原理解决实验中汉字字库的存储扩展问题，并能够使用正确的字库数据填充。
计组头哥实验 实验四 MIPS运算器设计
gdz0007的博客
06-21 5939
算术逻辑运算单元（ALU）的基本构成，掌握 Logisim 中各种运算组件的使用方法，熟悉多路选择器的使用，能利用前述实验完成的32位加法器、 Logisim 中的运算组件构造指定规格的 ALU 单元。
【区域填充】中的扫描线填充算法，活性边表AET，新边表NET
热门推荐
ZY_cat的博客
10-09 1万+
一、基本扫描线填充算法基础知识 （1）假定多边形的顶点已知 （2）基本思想：按扫描线从下到上扫描，一条一条确定区域内的像素 （3）步骤： ①求交。计算扫描线与多边形各边的交点。 ②排序。把所有交点按x值的递增顺序排序。x1、x2、x3、x4、x5、x6…… ③配对。[x1, x2]，[ x3, x4] , [x5, x6]……每对交点代表扫描线
扫描线填充算法
多看多听多总结
08-23 4835
1、基本思想 用水平扫描线从上到下（或者从下到上）扫描由多条首尾相连的线段构成的多边形，每根扫描线与多边形的某些边产生一系列交点。将这些交点按照x坐标排序，将排序后的点两两成对，作为线段的两个端点，以所填的颜色画水平直线。多边形被扫描完毕后，颜色填充也完成了。包含4个步骤 求交，计算扫描线与多边形的交点 交点排序，对第2步得到的交点按照x值从小到大进行排序。 颜色填充，对排序后的交点两两组成一个水平线段，以画线段的方式进行颜色填充。 是否完成多边形扫描？如果是结束算法，否则改变扫描线，然后转第1步
任意多边形填充 c++
09-07
任意多边形填充C，是指使用编程语言C来实现为任意形状的多边形填充颜色。多边形是由一系列顶点连接而成的闭合图形，而填充则是指将多边形内部的区域填充上某种颜色。 在C语言中，可以使用图形库或者图形API来实现...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值