Sutherland-Hodgeman 多边形裁剪算法

最新推荐文章于 2023-01-01 17:35:35 发布
最新推荐文章于 2023-01-01 17:35:35 发布
阅读量1.3k 收藏 10
点赞数 2
分类专栏： 计算机图形学 文章标签： 图形学 c++ opengl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43347376/article/details/118659198
版权

文章目录

说明

在阅读此博客前，请访问2018级山东大学计算机学院图形学实验汇总。

原笔记通过latex编写，csdn只支持latex部分功能，所以下面主要是将pdf截屏上传。部分内容参考中国农业大学mooc。

Sutherland-Hodgeman

算法较为简单，直接看课本就可以。

在这里插入图片描述在这里插入图片描述

代码

/*
 * 项目名称：Sutherland-Hodgeman
 * 注意：polyPoint中存储的是多边形的所有顶点，每个顶点仅仅存一次
 * 问题：processInput中，有一个崩溃bug，已经避免，但是不知道为什么有bug
 */
#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include "shader.h"
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <vector>
using namespace std;

const unsigned int MAXN = 800*600*2;
const unsigned int SCR_WIDTH = 800;
const unsigned int SCR_HEIGHT = 600;
const char* vertexShaderPath="/Users/longzhengtian/Desktop/代码/C++代码/ComputerGraphics/shader.vs";
const char* fragmentShaderPath="/Users/longzhengtian/Desktop/代码/C++代码/ComputerGraphics/shader.fs";

struct Point{
    double x,y;
    Point(double _x=0,double _y=0):x(_x),y(_y){};
    Point&operator=(const Point &p){
        x=p.x; y=p.y;
        return *this;
    };
    bool operator ==(const Point &p){
        return (x==p.x&&y==p.y);
    }
}templine[2];
vector<Point> polyPoint;//多边形
vector<Point> cropPoint;//裁剪点
struct Rectangle{
    double xleft,xright,ytop,ybottom;
}rec;//裁剪窗口，注意，xleft<xright,ytop<ybottom，这是窗口坐标决定的，左上角坐标是(0, 0)，左上角是(xleft,ytop)，但是ytop比ybottom小

bool DrawRec=false,DrawPoly=false;
bool DrawPolyEnd=false,DrawRecEnd=false;

int clickwho=-1;
unsigned int VBO[4], VAO[4];

void framebuffer_size_callback(GLFWwindow* window, int width, int height);
void processInput(GLFWwindow *window);
void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods);
void mouse_button_callback(GLFWwindow* window, int button, int action, int mods);
void SutherlandHodgeman(vector<Point> part_polyPoint,vector<Point> &part_cropPoint,const Rectangle &part_rec);

float transX(double x){return (float)((float)(2*x)-SCR_WIDTH)/(SCR_WIDTH*1.0f);}
float transY(double y){return (float)(SCR_HEIGHT-2*(float)y)/(SCR_HEIGHT*1.0f);}

bool distant(Point p1,Point p2){return (pow(fabs(p1.x-p2.x),2)+pow(fabs(p1.y-p2.y),2)<=25);}
bool IsItOnTheVisibleSide(const Point &p,const int &id,const Rectangle &part_rec);

Point GetTheIntersection(const Point &p1,const Point &p2,const int &id,const Rectangle &part_rec);

int main(){
    //实例化glfw函数
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
#ifdef __APPLE__
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
#endif

    //创建glfw窗口
    GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "Sutherland-Hodgeman", nullptr, nullptr);
    if (window == nullptr){
        cout << "Failed to create GLFW window" << endl;
        glfwTerminate();
        return -1;
    }

    glfwMakeContextCurrent(window);//将window设置为接下来操作的主窗口
    glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
    glfwSetKeyCallback(window, key_callback);
    glfwSetMouseButtonCallback(window, mouse_button_callback);

    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)){//使用glad加载glfw的所有函数指针
        cout << "Failed to initialize GLAD" << endl;
        return -1;
    }

    Shader ourShader(vertexShaderPath,fragmentShaderPath);//创建着色器程序

    float RecVertices[13];//裁剪窗口
    float Poly1Vertices[MAXN];//原始线
    float Poly2Vertices[MAXN];//裁剪窗口里面的线
    float TempLineVertices[7];//临时边

    glGenVertexArrays(4, VAO);
    glGenBuffers(4, VBO);

    glBindVertexArray(VAO[0]);
    glBindBuffer(GL_ARRAY_BUFFER, VBO[0]);
    glBufferData(GL_ARRAY_BUFFER, sizeof(RecVertices), RecVertices, GL_DYNAMIC_DRAW);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);

    glBindVertexArray(VAO[1]);
    glBindBuffer(GL_ARRAY_BUFFER, VBO[1]);
    glBufferData(GL_ARRAY_BUFFER, sizeof(Poly1Vertices), Poly1Vertices, GL_DYNAMIC_DRAW);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);

    glBindVertexArray(VAO[2]);
    glBindBuffer(GL_ARRAY_BUFFER, VBO[2]);
    glBufferData(GL_ARRAY_BUFFER, sizeof(Poly2Vertices), Poly2Vertices, GL_DYNAMIC_DRAW);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);

    glBindVertexArray(VAO[3]);
    glBindBuffer(GL_ARRAY_BUFFER, VBO[3]);
    glBufferData(GL_ARRAY_BUFFER, sizeof(TempLineVertices), TempLineVertices, GL_DYNAMIC_DRAW);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);

    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindVertexArray(0);

    glEnable(GL_LINE_SMOOTH);//启用线宽
    glLineWidth(10);
    glEnable(GL_PROGRAM_POINT_SIZE);
    glPointSize(10);

    while (!glfwWindowShouldClose(window)){
        //输入
        processInput(window);

        //渲染命令
        glClearColor(0.7f, 0.7f, 0.7f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);

        //裁剪窗口
        //ourShader.setVec4("ourColor",greenValue,blueValue,redValue,1.0f);
        ourShader.setVec4("ourColor",1.0f,1.0f,1.0f,1.0f);
        ourShader.use();
        glBindVertexArray(VAO[0]);
        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

        //主多边形
        ourShader.setVec4("ourColor",1.0f,0.0f,0.0f,1.0f);
        ourShader.use();
        glBindVertexArray(VAO[1]);
        if(DrawPoly) glDrawArrays(GL_LINE_STRIP, 0, polyPoint.size());
        else glDrawArrays(GL_LINE_LOOP, 0, polyPoint.size());

        //裁剪多边形
        ourShader.setVec4("ourColor",0.0f,0.0f,0.0f,1.0f);
        ourShader.use();
        glBindVertexArray(VAO[2]);
        glDrawArrays(GL_LINE_LOOP, 0, cropPoint.size());

        //临时边
        ourShader.setVec4("ourColor",1.0f,0.0f,0.0f,1.0f);
        ourShader.use();
        glBindVertexArray(VAO[3]);
        glDrawArrays(GL_LINES, 0, 2);

        //检查并调用事件，交换缓冲
        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    glDeleteVertexArrays(4, VAO);
    glDeleteBuffers(4, VBO);
    glfwTerminate();
    return 0;
}
Point GetTheIntersection(const Point &p1,const Point &p2,const int &id,const Rectangle &part_rec){//获得交点
    if(id==0) return {((part_rec.ybottom-p1.y)/(p2.y-p1.y))*(p2.x-p1.x)+p1.x,part_rec.ybottom};
    else if(id==1) return {part_rec.xright,((part_rec.xright-p1.x)/(p2.x-p1.x))*(p2.y-p1.y)+p1.y};
    else if(id==2) return {((part_rec.ytop-p1.y)/(p2.y-p1.y))*(p2.x-p1.x)+p1.x,part_rec.ytop};
    else return {part_rec.xleft,((part_rec.xleft-p1.x)/(p2.x-p1.x))*(p2.y-p1.y)+p1.y};
}
bool IsItOnTheVisibleSide(const Point &p,const int &id,const Rectangle &part_rec){//判断是否在可见侧
    if(id==0) return p.y>=part_rec.ybottom;
    else if(id==1) return p.x<=part_rec.xright;
    else if(id==2) return p.y<=part_rec.ytop;
    else return p.x>=part_rec.xleft;
}
void SutherlandHodgeman(vector<Point> part_polyPoint,vector<Point> &part_cropPoint,const Rectangle &part_rec){
    /* 按照这个顺序
     * Point windowPoint[4]={{part_rec.xleft,part_rec.ybottom},
     *                  {part_rec.xright,part_rec.ybottom},
     *                  {part_rec.xright,part_rec.ytop},
     *                  {part_rec.xleft,part_rec.ytop}};
     * double windowLine[4]={part_rec.ybottom,part_rec.xright,part_rec.ytop,part_rec.xleft};
     */
    part_cropPoint.clear();
    vector<float> tempvToCrop;
    for (int i=0; i<4; i++){//对于四条边
        for (int j=0; j<part_polyPoint.size(); j++){//对于多边形的剩余顶点
            int nextpolyid=(j+1)%part_polyPoint.size();
            if(!IsItOnTheVisibleSide(part_polyPoint[j],i,part_rec) && IsItOnTheVisibleSide(part_polyPoint[nextpolyid],i,part_rec)){//p1不可见，p2可见
                Point tempIntersection=GetTheIntersection(part_polyPoint[j],part_polyPoint[nextpolyid],i,part_rec);//交点
                part_cropPoint.push_back(tempIntersection);
                part_cropPoint.push_back(part_polyPoint[nextpolyid]);
            }
            else if(IsItOnTheVisibleSide(part_polyPoint[j],i,part_rec) && IsItOnTheVisibleSide(part_polyPoint[nextpolyid],i,part_rec)){//p1可见，p2可见
                part_cropPoint.push_back(part_polyPoint[nextpolyid]);
            }
            else if(IsItOnTheVisibleSide(part_polyPoint[j],i,part_rec) && !IsItOnTheVisibleSide(part_polyPoint[nextpolyid],i,part_rec)){//p1可见，p2不可见
                Point tempIntersection=GetTheIntersection(part_polyPoint[j],part_polyPoint[nextpolyid],i,part_rec);//交点
                part_cropPoint.push_back(tempIntersection);
            }
        }
        if(i!=3){//剩余顶点作为新的多边形
            part_polyPoint.clear();
            for (auto it:part_cropPoint) part_polyPoint.push_back(it);
            part_cropPoint.clear();
        }
    }
    for (auto it:part_cropPoint){
        tempvToCrop.push_back(transX(it.x));
        tempvToCrop.push_back(transY(it.y));
        tempvToCrop.push_back(1.0f);
    }
    float* tempfToCrop=tempvToCrop.data();
    glBindBuffer(GL_ARRAY_BUFFER, VBO[2]);
    glBufferSubData(GL_ARRAY_BUFFER, 0, tempvToCrop.size() * sizeof(float), tempfToCrop);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
}
void processInput(GLFWwindow *window){
    if(DrawPoly){//如果此时已经开始画多边形，这里是画临时边
        double xpos,ypos;
        glfwGetCursorPos(window,&xpos,&ypos);
        templine[0]=polyPoint[polyPoint.size()-1];
        templine[1]=Point((int)xpos,(int)ypos);
        float tempvec[]={transX(templine[0].x),transY(templine[0].y),1.0f,
                         transX(templine[1].x),transY(templine[1].y),1.0f
        };
        glBindBuffer(GL_ARRAY_BUFFER, VBO[3]);
        glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(tempvec), &tempvec);
        glBindBuffer(GL_ARRAY_BUFFER, 0);
    }
    else if(clickwho>=0 && clickwho<=3){//此时应该改变矩形
        double xpos,ypos;
        glfwGetCursorPos(window,&xpos,&ypos);
        if(clickwho==0){rec.xleft=xpos; rec.ybottom=ypos;}//"左下"
        else if(clickwho==1){rec.xright=xpos; rec.ytop=ypos;}//"右上"
        else if(clickwho==2){rec.xleft=xpos; rec.ytop=ypos;}//"左上"
        else if(clickwho==3){rec.xright=xpos; rec.ybottom=ypos;}//"右下"
        float tempvec[]={transX(rec.xleft),transY(rec.ybottom),1.0f,
                         transX(rec.xleft),transY(rec.ytop),1.0f,
                         transX(rec.xright),transY(rec.ybottom),1.0f,
                         transX(rec.xright),transY(rec.ytop),1.0f
        };
        glBindBuffer(GL_ARRAY_BUFFER, VBO[0]);
        glBufferSubData(GL_ARRAY_BUFFER,0,sizeof(tempvec),&tempvec);
        glBindBuffer(GL_ARRAY_BUFFER, 0);

        //裁剪
        if(DrawPolyEnd && DrawRecEnd) SutherlandHodgeman(polyPoint,cropPoint,rec);
    }
    else if(clickwho>=4){//移动多边形
        double xpos,ypos;
        glfwGetCursorPos(window,&xpos,&ypos);
        float tempvec[]={transX(xpos),transY(ypos),1.0f};
        glBindBuffer(GL_ARRAY_BUFFER, VBO[1]);
        glBufferSubData(GL_ARRAY_BUFFER, (clickwho-4)*3*sizeof(float), sizeof(tempvec), &tempvec);
        glBindBuffer(GL_ARRAY_BUFFER, 0);
        polyPoint[clickwho-4]=Point(xpos,ypos);

        //裁剪
        if(DrawPolyEnd && DrawRecEnd) SutherlandHodgeman(polyPoint,cropPoint,rec);
    }
}
void framebuffer_size_callback(GLFWwindow* window, int width, int height){
    glViewport(0, 0, width, height);
}
void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods){
    if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
        glfwSetWindowShouldClose(window, GL_TRUE);
    else if (key == GLFW_KEY_R && action == GLFW_PRESS) {//如果按下"R"，画裁剪窗口
        if(!DrawPoly){//此时不是属于画多边形时刻
            if(!DrawRec){//开始画窗口
                cout<<"You press ‘R’ to start drawing the crop window"<<endl;
                double xpos,ypos;
                glfwGetCursorPos(window,&xpos,&ypos);
                rec.xleft=xpos; rec.ybottom=ypos;
                clickwho=1;//此时的状态和点击了"右下"是一样的
                DrawRec=true;
            }
            else {//结束画窗口
                cout<<"You press ‘R’, drawing the cropping window ends"<<endl;
                clickwho=-1;
                DrawRec=false; DrawRecEnd=true;
                //裁剪
                if(DrawPolyEnd && DrawRecEnd) SutherlandHodgeman(polyPoint,cropPoint,rec);
            }
        }
    }
    else if (key == GLFW_KEY_P && action == GLFW_PRESS) {//如果按下"P"，画多边形
        if(!DrawRec){//此时不是属于画裁剪窗口时刻
            if(!DrawPoly){//开始画多边形
                polyPoint.clear(); cropPoint.clear();
                cout<<"You press ‘P’ to start drawing the polygon"<<endl;
                DrawPoly=true;
                double xpos,ypos;
                glfwGetCursorPos(window,&xpos,&ypos);
                float tempvec[]={transX(xpos),transY(ypos),1.0f};
                glBindBuffer(GL_ARRAY_BUFFER, VBO[1]);
                glBufferSubData(GL_ARRAY_BUFFER, polyPoint.size()*3*sizeof(float), sizeof(tempvec), &tempvec);
                glBindBuffer(GL_ARRAY_BUFFER, 0);
                polyPoint.emplace_back(xpos,ypos);
            }
            else {//结束画多边形
                cout<<"You press ‘P’ and the polygon drawing ends"<<endl;
                //处理临时边
                templine[0]=Point(0,0);
                templine[1]=Point(0,0);
                float tempvec1[]={0.0f,0.0f,1.0f,
                                 0.0f,0.0f,1.0f
                };
                glBindBuffer(GL_ARRAY_BUFFER, VBO[3]);
                glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(tempvec1), &tempvec1);
                glBindBuffer(GL_ARRAY_BUFFER, 0);
                DrawPoly=false; DrawPolyEnd=true;

                //裁剪
                if(DrawPolyEnd && DrawRecEnd) SutherlandHodgeman(polyPoint,cropPoint,rec);
            }
        }
    }
}
void mouse_button_callback(GLFWwindow* window, int button, int action, int mods){
    if(button == GLFW_MOUSE_BUTTON_LEFT && action == GLFW_PRESS){//鼠标点击了左键
        double xpos,ypos;
        glfwGetCursorPos(window,&xpos,&ypos);
        if(DrawPoly){//如果此时正在画多边形
            float tempvec[]={transX(xpos),transY(ypos),1.0f};
            glBindBuffer(GL_ARRAY_BUFFER, VBO[1]);
            glBufferSubData(GL_ARRAY_BUFFER, polyPoint.size()*3*sizeof(float), sizeof(tempvec), &tempvec);
            glBindBuffer(GL_ARRAY_BUFFER, 0);
            polyPoint.emplace_back(xpos,ypos);
        }
        else if(!DrawRec){//如果此时没有画矩形
            if(clickwho!=-1) clickwho=-1;//移动中点击了鼠标，肯定是要结束了
            else if(distant({rec.xleft,rec.ybottom},{xpos,ypos})) clickwho=0;//点击矩形"左下"
            else if(distant({rec.xright,rec.ytop},{xpos,ypos})) clickwho=1;//点击矩形"右上"
            else if(distant({rec.xleft,rec.ytop},{xpos,ypos})) clickwho=2;//点击矩形"左上"
            else if(distant({rec.xright,rec.ybottom},{xpos,ypos})) clickwho=3;//点击矩形"右下"
            else {
                for (int i=0; i<polyPoint.size(); i++){//点击的点是多边形上的点
                    if(distant({xpos,ypos},polyPoint[i])){
                        clickwho=i+4; return;
                    }
                }
                //没有点击到特殊的点，不进行任何操作
            }
        }

    }
}
龙征天
关注
  • 2
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
计算机图形学（六）多边形裁剪Sutherland-Hodgeman算法讲解与源代码
菜鸟
04-21 1万+
源码下载：因为最近CSDN上传资源出现问题，无法上传，等可以上传之后再给出下载地址。 首先讲一下算法的原理： Sutherland-Hodgeman算法： 基本思想是一次用窗口的一条边裁剪多边形。 考虑窗口的一条边以及延长线构成的裁剪线，该线把平面分成两个部分：可见一侧；不可见一侧。 多边形的各条边的两端点S、P。它们与裁剪线的位置关系只有四种， 如图： S、P与裁剪线的位置
计算机图形学实验六-多边形的Sutherland-Hodgman裁减算法
最新发布
weixin_53249260的博客
08-21 1051
这里绘制多边形，顶点的输入有两种形式，一个是鼠标点击，一个是用户手动输入，因为这里选择的OpenGL 中的模型视图矩阵堆栈是GL_MODELVIEW，这样相当于设置坐标轴位于画布中间，但是用户鼠标点击的时候，存入的顶点根据输出验证可以看出均为正值，说明这里用户用鼠标点击绘制的图像只能位于第一象限，若想让图像均匀分布在画布上，或者用户想精准绘制多边形，则可选用键盘输入的选项，若用户只是想快速绘制多边形，观察裁剪效果，则可以选择鼠标点击绘制多边形，若绘制结果不理想，可以按下键盘上的0键，重新绘制。
Sutherland–Hodgman 算法介绍(简单易懂)
Curz酥的博客
01-01 5808
计算机图形学笔记，简单易懂
Sutherland-Hodgman算法(多边形裁剪)
Muto_33的博客
03-04 1万+
用链表方法实现： #include #include using namespace std; int result[50][2] = { {10, 80},{70, 10},{80, 80},{90, 10},{130, 80},{80, 130}}; enum mark { L, B, R, T}; int c = -1; struct node { float data[2]; nod
Sutherland-Hodgeman 逐次裁剪法（多边形裁剪）.zip
11-05
在 pycharm 加 pyqt5环境中开发，python实现Sutherland-Hodge 逐次裁剪法（多边形裁剪）。 有优美的 UI界面
Sutherland_Hodgeman裁剪算法
03-25
Sutherland-Hodgeman裁剪算法基于多边形边界框（bounding box）的概念。首先，确定一个裁剪窗口，这个窗口定义了可见区域。然后，将多边形与窗口的每个边界逐一比较，根据比较结果决定哪些顶点在窗口内，哪些在窗口...
Sutherland-Hodgeman算法
08-07
**Sutherland-Hodgeman算法**是计算机图形学领域中的一种经典算法，主要用于多边形裁剪。在二维空间中，当需要在一个指定的视窗或屏幕区域内显示一个可能超出该区域的多边形时，就需要用到这种裁剪算法。它能够有效...
利用VC++实现Sutherland-Hodgman算法（多边形裁剪）
10-02
Sutherland-Hodgman算法是一种经典的计算机图形学中的多边形裁剪算法，主要用于处理二维图形。在VC++环境中，我们可以使用MFC（Microsoft Foundation Classes）框架来实现这个算法。MFC是微软提供的一种C++类库，它...
计算机图形学OpenGL、codeblock、多边形裁剪、Sutherland_Hodgman算法
12-20
Cohen-Sutherland线段裁剪算法是一种用于直线裁剪的经典算法，它可以判断一条线段是否完全在屏幕内、完全在屏幕外，或者需要进行裁剪。该算法通过定义一个裁剪窗口，并给每个端点分配一个编码，根据编码判断线段是否...
计算机图形学常用算法实现10 多边形裁剪Sutherland-Hodgman算法
Magic_Conch
11-30 4795
算法原理比较简单，用裁剪区域的四条边分别去分割多边形。 假设边p1，p2,用区域某条边进行裁剪。方向为p1-&amp;amp;amp;gt;p2 1.p1在边外，p2在边外 无操作 2.p1外，p2内 保存交点p和p2 3.p1内，p2内 保存p2 4.p1内，p2外 保存交点 分割完之后更新多边形的点集 代码裁剪区域为（200,200）到（400,400） private void SutherlandHodgm...
Sutherland-Hodgman算法进行多边形裁剪
06-24
用Sutherland-Hodgman算法进行多边形裁剪 鼠标画多边形,然后裁剪...算法有点问题，有时正确，有时错误.... 但其中技巧望大家认真看代码
matlab，SutherlandHodgeman等算法进行多边形被矩形截
03-30
可以实现任意多边形定点参数输入然后使用SutherlandHodgeman等算法进行多边形被矩形截
Sutherland-Hodgeman多边形裁剪（转载）
借你一秒
10-13 8299
Sutherland-Hodgeman多边形裁剪 　　Sutherland-Hodgman算法也叫逐边裁剪法，该算法是萨瑟兰德(I．E．Sutherland)和霍德曼(Hodgman)在1974年提出的。这种算法采用了分割处理、逐边裁剪的方法。 　　一、Sutherland-Hodgeman多边形裁剪算法思想： 　　每次用窗口的一条边界(包括延长线)对要裁剪的多边形进行裁剪，裁剪时，顺序
Sutherland－Hodgeman 和Cohen—Sutherland算法
借你一秒
05-03 6798
一、Cohen-Sutherland剪裁算法 1.基本思想 对于每条线段P1P2分为三种情况处理: （1）若P1P2完全在窗口内，则显示该线段P1P2。 （2）若P1P2明显在窗口外，则丢弃该线段。 （3）若线段不满足（1）或（2）的条件，则在交点处把线段分为两段。其中一段完全在窗口外，可弃之。然后对另一段重复上述处理。 为快速判断，采用如下编码方法：  
多边形裁剪一：Sutherland-Hodgman算法
热门推荐
我的新博客
01-29 3万+
Sutherland-Hodgman算法          Sutherland-Hodgman算法也叫逐边裁剪法，该算法是萨瑟兰德(I．E．Sutherland)和霍德曼(Hodgman)在1974年提出的。这种算法采用了分割处理、逐边裁剪的方法。 一，基本思想:          一次用窗口的一条边裁剪多边形。         考虑窗口的一条边以及延长线构成的裁剪线该线把平面分成两个部
matlab里用多边形裁剪图片,Sutherland—Hodgman 多边形裁剪算法步骤
weixin_29019241的博客
03-16 729
代码：#include#include#include#includestruct point{double x;double y;bool exist;};struct edge{struct point s;struct point e;};double max(double a, double b){if(a > b) return a;else return b;}double mi...
Sutherland-Hodgman裁剪算法(附c++源码)
sinat_33916407的博客
04-03 4081
这是一个关于多边形的裁剪算法，剪裁的是多边形，关于直线的剪裁，博主在https://blog.csdn.net/sinat_33916407/article/details/88918553 里面给出了梁友栋-Barskey裁剪算法的实现，在这里，博主给出的是多边形剪裁方法中的Sutherland-Hodgman方法，亲测可用，按下c键进行剪裁，按下r键会复原原图，按下x键会退出。是用vector...
多边形裁剪
一句话新闻
10-31 1114
最近有个兄弟一直被一个问题困扰着，就是这个题目的问题。突然我又一点想法，感觉应该比较好实现。下面简单说明一下，版权所有啊 ^_^首先声明，关于这方面我看的书很少，这个方法也是我集中生智想到的。肯定有什么漏洞啊，什么的。欢迎大家批评 ^_^假设有规则凸多边形a（例如，矩形，或者说屏幕，其定点为A1,A2,A3,...）和任意多边形b（被显示的图像，其定点为）多边形的表示法：认为多边形
sutherland-hodgeman多边形裁剪算法
06-28
Sutherland-Hodgeman多边形裁剪算法是一种计算机图形学中常用的算法，用于将一个多边形裁剪成另一个多边形。该算法的基本思想是将待裁剪的多边形按照裁剪边界的每条边进行切割，得到被裁剪后的多边形。该算法的优点...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值