头歌计算机图形学实验--直线裁剪

已于 2023-10-27 23:11:57 修改
阅读量1.4k 收藏 20
点赞数 4
分类专栏： 头歌计算机图形学实验 文章标签： 算法 c++
于 2023-10-27 22:54:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hanlepeng/article/details/134085372
版权

Cohen-Sutherland编码裁剪算法

// 评测代码所用头文件-开始
#include<opencv2/core/core.hpp>
#include<opencv2/highgui/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
// 评测代码所用头文件-结束

// 提示：写完代码请保存之后再进行评测
#include <GL/freeglut.h>
#include <stdio.h>

#define LEFT   1
#define RIGHT  2
#define BOTTOM 4
#define TOP    8

struct MyRect
{
	int xmin, xmax, ymin, ymax;
    MyRect() : xmin(), xmax(), ymin(), ymax(){};
    MyRect(int a, int b, int c, int d) : xmin(a), xmax(b), ymin(c), ymax(d){};
};

struct Point
{
	int x, y;
	Point() : x(), y() {};
	Point(int a, int b) :x(a), y(b) {};
};

MyRect  rect;
Point vPoint[6];

void LineGL(Point node1, Point node2)
{
	glBegin(GL_LINES);
	glColor3f(0.0f, 1.0f, 0.0f);   
    glVertex2f(node1.x, node1.y);
	glVertex2f(node2.x, node2.y);
	glEnd();
}

int CompCode(Point node, MyRect rect)
{
	// 请在此添加你的代码
   /********** Begin ********/




   /********** End **********/
}

void LineClipCohenSurtherland(MyRect rect, Point& node1, Point& node2)
{
	bool accept = true;
	// 请在此添加你的代码
   /********** Begin ********/




   /********** End **********/
	if (accept)
        LineGL(node1, node2);
}

void MyDisplay()
{
	glClear(GL_COLOR_BUFFER_BIT);
	glColor3f(1.0f, 1.0f, 1.0f);
	glRectf(rect.xmin, rect.ymin, rect.xmax, rect.ymax);

  	for (int i = 0; i < 5; i+=2) 
		LineClipCohenSurtherland(rect, vPoint[i], vPoint[i+1]);
	
	
	glFlush();
}

void Init()
{
	glClearColor(0.0, 0.0, 0.0, 0.0);
	glShadeModel(GL_FLAT);

    rect = MyRect(100, 300, 100, 300);

	vPoint[0] = Point(200, 50); vPoint[1] = Point(350, 250);
	vPoint[2] = Point(125, 205); vPoint[3] = Point(250, 255);
	vPoint[4] = Point(40, 150); vPoint[5] = Point(150, 40);
}

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_RGB | GLUT_SINGLE);
	glutInitWindowPosition(100, 100);
	glutInitWindowSize(400, 400);
	glutCreateWindow("Hello World!");

	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;
}

中点分割裁剪算法

// 评测代码所用头文件-开始
#include<opencv2/core/core.hpp>
#include<opencv2/highgui/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
// 评测代码所用头文件-结束

// 提示：写完代码请保存之后再进行评测
#include <GL/freeglut.h>
#include <stdio.h>

#define LEFT   1
#define RIGHT  2
#define BOTTOM 4
#define TOP    8

struct MyRect
{
	int xmin, xmax, ymin, ymax;
    MyRect() : xmin(), xmax(), ymin(), ymax(){};
    MyRect(int a, int b, int c, int d) : xmin(a), xmax(b), ymin(c), ymax(d){};
};


struct Point
{
	int x, y;
	Point() : x(), y() {};
	Point(int a, int b) :x(a), y(b) {};
};

MyRect  rect;
Point vPoint[6];

void LineGL(Point node1, Point node2)
{
	glBegin(GL_LINES);
	glColor3f(0.0f, 1.0f, 0.0f);   
    glVertex2f(node1.x, node1.y);
	glVertex2f(node2.x, node2.y);
	glEnd();
}

 int CompCode(Point node, MyRect rect)
{
    int code = 0x00;
    if (node.y < rect.ymin)
        code = code | BOTTOM;
    if (node.y > rect.ymax)
        code = code | TOP;
    if (node.x > rect.xmax)
        code = code | RIGHT;
    if (node.x < rect.xmin)
        code = code | LEFT;
    return code;
}

void LineClipMidPoint(MyRect rect, Point& node1, Point& node2)
{
	bool accept = true;
 Point start, end, mid;//分别代表起点，终点和中点
    int code1, code2, codemid;
    code1 = CompCode(node1, rect);
    code2 = CompCode(node2, rect);
    if(code1 == 0 && code2 == 0)
        accept = true;
    else if(code1 & code2)
        accept = false;
    else {
        if(code2!=0){
            start = node1; end = node2;
            mid = Point((float)(start.x + end.x)/(float)2 + 0.5, (float)(start.y + end.y)/(float)2 + 0.5);
            while(abs(start.x - mid.x)>1 || abs(start.y - mid.y)>1){
                codemid = CompCode(mid, rect);
                if(codemid==0){
                     start = mid;
                } 
                else{
                    end = mid;
                }
                mid = Point((float)(start.x + end.x)/(float)2 + 0.5, (float)(start.y + end.y)/(float)2 + 0.5);
            }
            node2 = mid;
        }
        if(code1!=0){
               start = node1; end = node2;
            mid = Point((float)(start.x + end.x)/(float)2 + 0.5, (float)(start.y + end.y)/(float)2 + 0.5);
            while(abs(start.x - mid.x)>1 || abs(start.y - mid.y)>1){
                codemid = CompCode(mid, rect);
                if(codemid==0){
                     end = mid;
                }
                else{
                     start = mid;
                }
                mid = Point((float)(start.x + end.x)/(float)2 + 0.5, (float)(start.y + end.y)/(float)2 + 0.5);
            }
            node1 = mid;
        }
    }
   /********** End **********/
	if (accept)
		LineGL(node1, node2);
}

void MyDisplay()
{
	glClear(GL_COLOR_BUFFER_BIT);
	glColor3f(1.0f, 1.0f, 1.0f);
	glRectf(rect.xmin, rect.ymin, rect.xmax, rect.ymax);

   for (int i = 0; i < 5; i+=2) 
		LineClipMidPoint(rect, vPoint[i], vPoint[i+1]);

	
	glFlush();
}

void Init()
{
	glClearColor(0.0, 0.0, 0.0, 0.0);
	glShadeModel(GL_FLAT);

	rect = MyRect(100, 300, 100, 300);

	vPoint[0] = Point(200, 50); vPoint[1] = Point(350, 250);
	vPoint[2] = Point(125, 205); vPoint[3] = Point(250, 255);
	vPoint[4] = Point(40, 150); vPoint[5] = Point(150, 40);
}

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_RGB | GLUT_SINGLE);
	glutInitWindowPosition(100, 100);
	glutInitWindowSize(400, 400);
	glutCreateWindow("Hello World!");

	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;
}

Liang-Barsky参数化裁剪算法

// 评测代码所用头文件-开始
#include<opencv2/core/core.hpp>
#include<opencv2/highgui/highgui.hpp>
#include<opencv2/imgproc/imgproc.hpp>
// 评测代码所用头文件-结束

// 提示：写完代码请保存之后再进行评测
#include <GL/freeglut.h>
#include <stdio.h>

struct MyRect
{
	int xmin, xmax, ymin, ymax;
    MyRect() : xmin(), xmax(), ymin(), ymax(){};
    MyRect(int a, int b, int c, int d) : xmin(a), xmax(b), ymin(c), ymax(d){};
};

struct Point
{
	int x, y;
	Point() : x(), y() {};
	Point(int a, int b) :x(a), y(b) {};
};

MyRect  rect;
Point vPoint[6];

void LineGL(Point node1, Point node2)
{
	glBegin(GL_LINES);
	glColor3f(0.0f, 1.0f, 0.0f);   
    glVertex2f(node1.x, node1.y);
	glVertex2f(node2.x, node2.y);
	glEnd();
}

int ClipTest(float p, float q, float* u1, float* u2)
{
    if (p < 0.0)
    {
        float r = q / p;
        if (r > *u2)
        {
            return 0;
        }
        else if (r > *u1)
        {
            *u1 = r;
        }
    }
    else if (p > 0.0)
    {
        float r = q / p;
        if (r < *u1)
        {
            return 0;
        }
        else if (r < *u2)
        {
            *u2 = r;
        }
    }
    else if (q < 0.0)
    {
        return 0;
    }
    return 1;
}

bool LineClipLiangBarsky(MyRect rect, Point& node1, Point& node2)
{
    float u1 = 0.0, u2 = 1.0;
    int dx = node2.x - node1.x;
    int dy = node2.y - node1.y;

    if (ClipTest(-dx, node1.x - rect.xmin, &u1, &u2))
    {
        if (ClipTest(dx, rect.xmax - node1.x, &u1, &u2))
        {
            if (ClipTest(-dy, node1.y - rect.ymin, &u1, &u2))
            {
                if (ClipTest(dy, rect.ymax - node1.y, &u1, &u2))
                {
                    if (u2 < 1.0)
                    {
                        node2.x = node1.x + u2*dx;
                        node2.y = node1.y + u2*dy;
                    }
                    if (u1 > 0.0)
                    {
                        node1.x = node1.x + u1*dx;
                        node1.y = node1.y + u1*dy;
                    }
                    return true;
                }
            }
        }
    }
    return false;
}

void MyDisplay()
{
	glClear(GL_COLOR_BUFFER_BIT);
	glColor3f(1.0f, 1.0f, 1.0f);
	glRectf(rect.xmin, rect.ymin, rect.xmax, rect.ymax);

	for(int i = 0; i < 5; i+=2){
        bool bAccept = LineClipLiangBarsky(rect, vPoint[i], vPoint[i+1]);
		if(bAccept)
            LineGL(vPoint[i], vPoint[i+1]);
	}
	
	glFlush();
}

void Init()
{
	glClearColor(0.0, 0.0, 0.0, 0.0);
	glShadeModel(GL_FLAT);

	rect = MyRect(100, 300, 100, 300);

	vPoint[0] = Point(200, 50); vPoint[1] = Point(350, 250);
	vPoint[2] = Point(125, 205); vPoint[3] = Point(250, 255);
	vPoint[4] = Point(40, 150); vPoint[5] = Point(150, 40);
}


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_RGB | GLUT_SINGLE);
	glutInitWindowPosition(100, 100);
	glutInitWindowSize(400, 400);
	glutCreateWindow("Hello World!");

	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;
}

 

 

 

程序员李知恩
关注
  • 4
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Cohen-SutherLand 裁剪算法 （vc++）
成长快乐
05-27 4132
 Cohen-SutherLand实现裁剪直线的两个关键函数 //计算点 x,y的编码void CCohenSutherLandView::CompOutCode(float x,float y,CRect* rect,OutCode* outCode){ outCode->all = 0; outCode->top = outCode->bottom =0; if (y top) {
计算机图形学实验四Cohen-Sutherland直线段裁剪算法
05-08
在"计算机图形学实验四Cohen-Sutherland直线段裁剪算法"中，学生通常会被要求实现这个算法，并通过编程验证其正确性。这不仅可以帮助他们深入理解计算机图形学的基本原理，还能锻炼他们的编程技巧和问题解决能力。...
计算机图形学 实验6 直线的裁剪—Cohen Sutherland裁剪算法（MFC中）
Confident_ZYL的博客
06-21 1万+
实验目的： 理解裁剪的作用 掌握直线裁剪的算法 实验内容： 一、编写程序实现Cohen Sutherland裁剪算法 算法原理： 首先判断直线段是否全部在窗口内，是，则保留；不是，则再判断是否完全在窗口之外，如是，则舍弃。 如果这两种情况都不属于，则将此直线段从交点处分割，对分割后的线段再进行如前判断。 直至所有直线段和由直线段分割出来的子线段都已经确定了是保留还是舍弃为止。 算法流程： 对直线的两个端点进行编码 编码方式 注意：l为left，r为right，b为bottom，t为top （1）若x小于w
计算机图形学 之 直线裁剪算法
HeroIsUseless的博客
09-22 2153
使用计算机处理图形信息时，计算机内部存储的图形往往比较大，而屏幕显示的知识图形的一部分。因此需要确定图形哪些部分落在显示区内，哪些落在显示区外。这个选择的过程就称为裁剪。 最简单的裁剪方法是把各种图形扫描转换为点之后，再判断点是否在窗口内。 要裁剪一条直线段，首先要判断（如下图所示）： 它是否完全落在裁剪窗口内？ 它是否完全在窗口外？ 如果不满足以上两个条件，则计算它与一个或多个裁剪边界的交点（比如线段AB）。 常用的裁剪算法由三种，即 Cohen-Suther land、中点分割法、Liang-
计算机图形学 学习笔记（四）：直线裁剪算法：Cohen-Suther land，中点分割法，Liang-Barsky
热门推荐
学愈进而愈惘
07-11 2万+
接上文 计算机图形学 学习笔记（三）：多边形的区域填充算法，反走样算法光栅图形学算法本文主要讲解直线裁剪算法。裁剪使用计算机处理图形信息时，计算机内部存储的图形往往比较大，而屏幕显示的知识图形的一部分。因此需要确定图形哪些部分落在显示区内，哪些落在显示区外。这个选择的过程就称为裁剪。最简单的裁剪方法是把各种图形扫描转换为点之后，再判断点是否在窗口内。1、点的裁剪但判断图形中每个点是否在窗口内，太费
Cohen-Sutherland线段裁剪算法
Every day
11-11 1868
出处：http://blog.csdn.net/liaojinyu282/article/details/6010253 通过一个矩形的裁剪区域将整个屏幕分成9个部分，并为每一个部分赋予相应的区域码，然后根据端点的位置确定这个端点的区域码。 先判断能否完全接受或者完全排除一条线段，若以上2个判断无法直接得出，则逐步裁剪，选取一个位于裁剪区外的端点，把端点的区域码和裁剪边界的
计算机图形学实验五-直线段的编码裁剪算法（Cohen-SutherLand算法）
weixin_53249260的博客
08-21 2065
连接和裁剪区域的4个角点的直线分别记为LT、RT、LB、RB，通过比较P0P1和这四条直线的斜率，可以确定直线的可见性、直线与区域边界的交点个数及交点所在边界。：参考Cohen-SutherLand算法的编码形式，定义编码函数，得到传入的点的坐标，首先判断是否完全可见，完全可见则直接绘制，完全不可见则直接抛弃，以上两种情况均不符合则为部分可见的情况，则开始判断起点所处的区域，针对三个不同的区域进行不同区域的处理，根据不同的斜率值进行不同交点的求解，这里就体现了NLN直线段裁剪算法的。
SDUWH计算机图形学实验--2020
10-22
2020--SDUWH--计算机图形学实验 共20个实验 实验1 直线的绘制 实验2 直线的DDA生成算法 实验3 直线中点生成算法 实验4 直线Bresenham生成算法 实验5 中点画圆算法 实验6 中点画椭圆算法 实验7 多边形有序边表算法 ...
计算机图形学(MFC)-直线段裁剪
03-24
在计算机图形学中，直线段裁剪是一项基础且关键的技术，尤其在2D图形渲染和交互式应用中广泛使用。MFC（Microsoft Foundation Classes）是微软提供的一套用于构建Windows应用程序的类库，它基于C++语言，简化了...
计算机图形学Cohen-Sutherland直线裁剪算法实验.pdf
10-06
计算机图形学Cohen-Sutherland直线裁剪算法实验 计算机图形学是计算机科学和数学的交叉领域，研究如何使用计算机来生成和操作图形和图像。其中的一种重要技术是直线裁剪算法，即将直线裁剪到某个窗口或视图中。...
Cohen-Sutherland直线裁剪算法 计算机图形学 孔令德 案例源码
12-28
Cohen-Sutherland直线裁剪算法 计算机图形学 孔令德 案例源码
计算机图形学Cohen-Sutherland直线裁剪算法实验收集.pdf
11-15
计算机图形学Cohen-Sutherland直线裁剪算法实验收集 本实验报告的主要内容是关于Cohen-Sutherland直线裁剪算法的实验实现。该算法是计算机图形学中的一种常用裁剪算法，用于裁剪直线以适应窗口的大小。 在实验中，...
计算机图形学：Cohen-Sutherland直线段剪裁算法及梁友栋-Barsky裁剪算法（算法原理及代码实现）
qq_55982881的博客
02-22 9064
一、算法实现原理 Cohen-Sutherland直线段剪裁算法： 算法原理： （1）判断线段两端是否都落在窗口内，如果是，则线段完全可见，否则进行下一步 （2）判断线段两端是否都落在窗口外，如果是，则线段完全不可见，否则进行下一步 （3）求线段与窗口延长线的交点，这个交点将线段分为两端，一段完全不可见丢弃，对剩下的一部分重新进行上述一、二操作，直到结束。 算法实现： 用窗口四条边所在的直线将整个二位平面分为9个区域，定义下界限为ymin，上界限为ymax，左界限为xmin，右界...
实验4 编码裁剪算法
图形学与可视化
04-17 3037
1．实验目的：了解二维图形裁剪的原理（点的裁剪、直线的裁剪、多边形的裁剪），利用VC+OpenGL实现直线的裁剪算法。2．实验内容：（1） 理解直线裁剪的原理（Cohen-Surtherland算法、梁友栋算法）（2） 利用VC+OpenGL实现直线的编码裁剪算法，在屏幕上用一个封闭矩形裁剪任意一条直线。（3） 调试、编译、修改程序。（4） 尝试实现梁友栋裁剪算法。3．实验原理：编码裁剪算法中，...
Cohen-Sutherland线裁剪算法
但行好事，莫问前程
10-22 5764
直线裁剪算法 裁剪：计算机内部存储的图形往往比较大，而屏幕显示的只是图形的一部分，因此需要确定图形哪些部分落在显示区之内，哪些落在显示区之外，这个选择的过程就称为裁剪。 1. 最简单的裁剪方法是把直线扫描变换为各点是否在窗口内。但此方法太费时，效率比较低，一般不可取。 对于任意一点P(x,y)若满足下列不等式，则点P在矩形窗口内 2. 直线段的裁剪——>复杂图形裁剪的基础 要裁剪一...
计算机图形学实验之直线段的编码裁剪算法（Cohen-SutherLand算法
xp1683464115的博客
11-28 419
库来创建窗口，并绘制了一个矩形框和一个经过裁剪的直线段。（可选）： 实现NLN直线段裁剪算法。： 掌握相关算法的原理及实现。,可以修改坐标来进行其他测试。
计算机图形学：直线段裁剪，Cohen-Sutherland算法
太酷啦
10-02 6540
在二维观察中，需要对窗口进行裁剪，即只保留窗口内的图形，去掉窗口外的图形。直线段裁剪即判断直线在窗口内的部分，去除在窗口外的部分。该算法基本思想为编码，即对于直线上任一点(x,y)，根据其坐标所在的区域，赋予一个4位的二进制码D3D2D1D0。由此得出直线的位置。
Cohen-Sutherland直线裁剪算法
姜希成的博客
06-23 1万+
在二维观察中，需要在观察坐标系下根据窗口大小对二维图形进行裁剪（clipping），只将位于窗口内的图形变换到视区输出。直线段裁剪是二维图形裁剪的基础，裁剪的实质是判断直线段是否与窗口相交，如相交则进一步确定直线段上位于窗口内的部分。 编码原理 Cohen-Sutherland直线段裁剪算法是最早流行的编码算法。每段直线的端点都被赋予一组四位二进制代码，称为区域编码(region code...
LC53最大子数组和、lc5最长回文子串、lc283移动零
最新发布
m0_47536537的博客
07-14 224
请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。连续子数组 [4,-1,2,1] 的和最大，为 6。移动到数组的末尾，同时保持非零元素的相对顺序。，必须在不复制数组的情况下原地对数组进行操作。"aba" 同样是符合题意的答案。是数组中的一个连续部分。，编写一个函数将所有。LC53最大子数组和。
计算机图形学实验指导：图形交互技术及基本算法
在计算机图形学实验中，学生将学习和实践图形交互技术、图形生成算法、图形变换和投影变换等内容。 实验1是图形交互技术实验。实验目的是了解图形交互的基本原理，并掌握图形交互的几种常用技术。实验内容是使用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值