计算机图形学头歌实训平台直线裁剪答案

最新推荐文章于 2024-08-14 13:01:01 发布
最新推荐文章于 2024-08-14 13:01:01 发布
阅读量684 收藏 11
点赞数 3
文章标签： 计算机视觉 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74822776/article/details/134385470
版权

第1关：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 ********/
 
int code = 0;
    if (node.x < rect.xmin)
        code |= LEFT;
    else if (node.x > rect.xmax)
        code |= RIGHT;
 
    if (node.y < rect.ymin)
        code |= BOTTOM;
    else if (node.y > rect.ymax)
        code |= TOP;
    
    return code;
 
 
   /********** End **********/
}
 
void LineClipCohenSurtherland(MyRect rect, Point& node1, Point& node2)
{
	bool accept = false;
	// 请在此添加你的代码
   /********** Begin ********/
    int code1 = CompCode(node1, rect);
    int code2 = CompCode(node2, rect);
 
    while (true)
    {
        if ((code1 | code2) == 0)
        {
            accept = true;
            break;
        }
        else if (code1 & code2)
        {
            break;
        }
        else
        {
            int code = (code1 != 0) ? code1 : code2;
            Point node;
            if (code & LEFT)
            {
                node.x = rect.xmin;
                node.y = node1.y + (node2.y - node1.y) * (rect.xmin - node1.x) / (node2.x - node1.x);
            }
            else if (code & RIGHT)
            {
                node.x = rect.xmax;
                node.y = node1.y + (node2.y - node1.y) * (rect.xmax - node1.x) / (node2.x - node1.x);
            }
            else if (code & BOTTOM)
            {
                node.y = rect.ymin;
                node.x = node1.x + (node2.x - node1.x) * (rect.ymin - node1.y) / (node2.y - node1.y);
            }
            else if (code & TOP)
            {
                node.y = rect.ymax;
                node.x = node1.x + (node2.x - node1.x) * (rect.ymax - node1.y) / (node2.y - node1.y);
            }
 
            if (code == code1)
            {
                node1 = node;
                code1 = CompCode(node1, rect);
            }
            else
            {
                node2 = node;
                code2 = CompCode(node2, rect);
            }
        }
    }
 
 
 
   /********** 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;
}

第2关：中点分割裁剪算法

// 评测代码所用头文件-开始
#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;
        }
    }
    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;
}

第3关：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;
}

一条僵小鱼
关注
  • 3
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
计算机图形学头歌实训平台答案——CG1-v2.0-直线绘制
m0_71869598的博客
09-27 3549
计算机图形学头歌实训平台答案——CG1-v2.0-直线绘制
裁剪算法——Cohen-Sutherland算法
qq_41342446的博客
05-25 7993
一、直线裁剪算法 1、裁剪：计算机内部存储的图形往往比较大，而屏幕显示的只是图形的一部分，因此需要确定图形哪些部分落在显示区之内，哪些落在显示区之外，这个选择的过程就称为裁剪。 1.1点的裁剪——>此方法太费时，效率比较低，一般不可取。 对于任意一点P(x,y)若满足下列不等式，则点P在矩形窗口内 1.2直线段的裁剪——>复杂图形裁剪的基础 要裁剪一条直线段，首先要判断此直线的位置： 1)它是否完全落在裁剪窗口内？ 2)它是否完全在窗口外？ 3)如果不满足以上两个条件，则计算它与一个或多个裁剪
头歌计算机图形学实验--直线裁剪
hanlepeng的博客
10-27 1544
【代码】头歌计算机图形学实验--直线裁剪。
计算机图形学头歌合集（题集附解）
醉蕤的博客
12-18 5341
别找啦openGL,你们要的答案都在这 点赞
计算机图形学头歌实训平台——二维几何变换
weixin_51329675的博客
01-05 2864
计算机图形学头歌实训平台——二维几何变换
【OpenGL】计算机图形学实验四: 直线、多边形裁剪实验(直线和多边形的裁剪)
JKL27的博客
07-09 5840
(直线和多边形的裁剪)1、实验目的和要求实验目的：实验内容：2、实验设备PC机、CodeBlocks\VS系列\OpenGL安装包3、实验内容及原理 实验原理(基本知识)1) Cohen-Sutherland裁剪算法又称编码裁剪算法，对每条直线段分三种情况处理： ① 如果点P1, P2完全在裁剪窗口内，则该直线段完全可见，“简取”之； ② 如果点P1, P2都在窗口外，且在窗口的同一外侧，则该直线段完全不可见，“简弃”之； ③ 若不满足“简取”和“简弃”的条件，则直线段可能与窗口相交
计算机图形学实验错误及解决方法,计算机图形学实验指导书.doc
weixin_42390041的博客
07-29 544
计算机图形学实验指导书.doc (10页) 本资源提供全文预览，点击全文预览即可全文预览,如果喜欢文档就下载吧，查找使用更方便哦！7.9 积分佛山科学技术学院计算机图形学实验指导书李晓东 编电信学院计算机系2011年 11月实验1 直线段的扫描转换实验类型：设计性实验类别：专业实验实验目的1. 通过实验，进一步理解直线段扫描转换的DDA算法、中点bresenham算法及bresenham算法的...
【计算机图形学】实验三 用Cohen-Sutherland裁剪算法实现直线段裁剪
进一步有一步的欢喜
02-04 1520
一、实验目的及要求 本实验旨在实现直线段的裁剪，使用Cohen-Sutherland裁剪算法进行处理。通过输入直线段的起点和终点坐标，并指定裁剪窗口（矩形），对直线段进行裁剪，并输出裁剪后的结果。
计算机图形学实验四Cohen-Sutherland直线段裁剪算法
05-08
在"计算机图形学实验四Cohen-Sutherland直线段裁剪算法"中，学生通常会被要求实现这个算法，并通过编程验证其正确性。这不仅可以帮助他们深入理解计算机图形学的基本原理，还能锻炼他们的编程技巧和问题解决能力。...
计算机图形学直线和多边形裁剪
05-14
本资源包含了Cohen-Sutherland算法、Liang-Barsky算法实现直线段裁剪以及自创的多边形裁剪（老师都没查出BUG）的cpp源代码和实验报告。重点是多边形裁剪，400多行代码，最终实现了任意多边形裁剪，下载即可运行
计算机图形学(MFC)-直线段裁剪
03-24
在计算机图形学中，直线段裁剪是一项基础且关键的技术，尤其在2D图形渲染和交互式应用中广泛使用。MFC（Microsoft Foundation Classes）是微软提供的一套用于构建Windows应用程序的类库，它基于C++语言，简化了...
计算机图形学模拟试卷和答案
04-24
计算机图形学是一门涵盖多个领域的学科，主要涉及利用算法生成和操作二维或三维图形。它在游戏开发、影视特效、虚拟现实、工程设计等多个领域有着广泛的应用。本篇内容主要涵盖了计算机图形学的一些核心概念和知识，...
计算机图形学作业源程序
03-06
综上所述，这个计算机图形学作业涵盖了基础的图形绘制算法，如直线、圆和椭圆，以及高级的填充、裁剪和贝塞尔曲线绘制技术，同时还涉及到实时动画的实现。这些知识点对于理解和开发2D图形应用至关重要。通过学习和...
国外项目管理软件最佳实践：选型与应用
柚橙论
08-13 966
在选择适合自己团队的项目管理软件时，了解各种工具的功能、优势和适用场景至关重要。从Asana的灵活性到Trello的直观看板，再到Monday.com的强大定制功能，每款软件都有其独特之处，可以满足不同类型项目和团队的需求。通过本文的介绍，希望您能对这些工具有了更深入的了解，并能够根据自己的实际需求做出明智的选择。无论您的团队规模如何，选择正确的项目管理工具都将是提升工作效率和项目成功率的关键一步。在数字化快速发展的今天，利用合适的项目管理软件，不仅可以优化工作流程，还可以激发团队潜力，推动业务持续发展。
【图像去雾系列】使用SSR/MSR/MSRCR/MSRCP/automatedMSRCR算法对单图像进行图像增强，达到去雾效果
最新发布
静谧、淡雅
08-14 206
【图像去雾系列】使用SSR/MSR/MSRCR/MSRCP/automatedMSRCR算法对单图像进行图像增强，达到去雾效果
Depth Anything: Unleashing the Power of Large-Scale Unlabeled Data精读
weixin_49053303的博客
08-13 400
这项工作介绍了 Depth Anything1，一个高度实用的解决方案，用于稳健的单目深度估计。我们不追求新的技术模块，而是旨在构建一个简单而强大的基础模型，以处理任何环境下的图像。为此，我们通过设计一个数据引擎来收集和自动标注大规模的未标记数据（约6200万），从而显著扩大数据覆盖范围，减少泛化误差。我们探讨了两种简单而有效的策略，使得数据规模的扩大变得有希望。首先，通过利用数据增强工具创建了一个更具挑战性的优化目标，迫使模型积极寻求额外的视觉知识并获取稳健的表征。
论文阅读笔记：Efficient Teacher: Semi-Supervised Object Detection for YOLOv5
HollowKnightz的博客
08-12 788
论文阅读笔记：Efficient Teacher: Semi-Supervised Object Detection for YOLOv5
FreqNet——通过频率感知进行深度伪造检测算法研究
知来者逆的博客
08-12 684
作者提出的 FreqNet 是一种轻量级模型，用于通用检测由各种生成模型创建的虚假图像；FreqNet 的一个显著特点是将频率分析明确纳入网络框架。因此，与传统模型相比，FreqNet 用更少的参数就能达到最先进的水平。这支持了本研究中给出的策略的有效性。另一方面，作者主要关注的是由 GAN 生成的假图像，但 FreqNet 是否也适用于其他生成模型（如扩散模型）生成的图像仍有待商榷。未来，FreqNet 预计将用于由扩散模型和其他模型创建的图像，以获得进一步的多功能性。
计算机图形学：裁剪技术与直线裁剪算法解析
"计算机图形学--第五讲 裁剪的基本概念与直线裁剪.pdf" 计算机图形学是研究如何在计算机系统中表示、处理和显示图形的学科，它涉及到多个领域，如几何建模、渲染、交互等。在这一讲中，主要探讨的是裁剪这一关键...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值