AI 助理
备案控制台
开发者社区 人工智能 文章 正文

计算机图形学——实验五 基本图形学算法及着色器初步编程

2022-10-18 317
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
Redis 开源版，标准版 2GB
推荐场景：
搭建游戏排行榜
云数据库 Tair（兼容Redis），内存型 2GB
推荐场景：
通过缓存加速数据库访问
简介： 实验五 基本图形学算法及着色器初步编程1、 理解基本图形元素光栅化的基本原理，理解直线裁剪算法的原理；2、 掌握直线的光栅化算法：DDA和Bresenham算法；3、 掌握直线裁剪算法：Cohen-Surtherland算法；1、 编程实现DDA算法和Bresenham算法生成直线。2、 实现Cohen-Surtherland直线裁剪算法，调试、编译、修改程序。要求：根据所给的直线光栅化的示范源程序，在计算机上编译运行，输出正确结果（示范代码有错误，指出并改正）。

实验五 基本图形学算法及着色器初步编程

实验项目性质：验证性实验

所属课程名称：计算机图形学A

实验计划学时：3学时

一、实验目的

    1. 理解基本图形元素光栅化的基本原理，理解直线裁剪算法的原理；
    2. 掌握直线的光栅化算法：DDA和Bresenham算法；
    3. 掌握直线裁剪算法：Cohen-Surtherland算法；

    二、实验内容

      1. 编程实现DDA算法和Bresenham算法生成直线。
      2. 实现Cohen-Surtherland直线裁剪算法，调试、编译、修改程序。

      三、实验代码

      1.直线光栅化DDA算法

      //DDA算法
#include <GL/glut.h>
void LineDDA(int x0, int y0, int x1, int y1)
{
  int x, dy, dx, y;
  float m;
  dx = x1 - x0;
  dy = y1 - y0;
  m = dy / dx;
  y = y0;
  glColor3f(1.0f, 1.0f, 0.0f);
  glPointSize(1);
  for (x = x0; x <= x1; x++)
  {
    glBegin(GL_POINTS);
    glVertex2i(x, (int)(y + 0.5));
    glEnd();
    y += m;
  }
}
void myDisplay(void)
{
  glClear(GL_COLOR_BUFFER_BIT);
  glColor3f(1.0f, 0.0f, 0.0f);
  glRectf(25.0, 25.0, 75.0, 75.0);
  glPointSize(5);
  glBegin(GL_POINTS);
  glColor3f(0.0f, 1.0f, 0.0f);  glVertex2f(0.0f, 0.0f);
  glEnd();
  LineDDA(0, 0, 200, 300);
  glBegin(GL_LINES);
  glColor3f(1.0f, 0.0f, 0.0f); glVertex2f(100.0f, 0.0f);
  glColor3f(0.0f, 1.0f, 0.0f); glVertex2f(180.0f, 240.0f);
  glEnd();
  glFlush();
}
void Init()
{
  glClearColor(0.0, 0.0, 0.0, 0.0);
  glShadeModel(GL_FLAT);
}
void Reshape(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(Reshape);
  glutMainLoop();
  return 0;
}

      image.gif

      要求：

      根据所给的直线光栅化的示范源程序，在计算机上编译运行，输出正确结果（示范代码有错误，指出并改正）。

      2.直线光栅化Bresenham算法

      # include "stdafx.h"
# include <GL/glut.h>
# include <windows.h>
# include <math.h>
void MidBresenhamLine(int x0, int y0, int x1, int y1)
{
  int dx, dy, d, UpIncre, DownIncre, x, y;
  if(x0>x1)
  {
    x = x1; x1 = x0; x0 = x;
    y = y1; y1 = y0; y0 = y;
  }
  x = x0; y = y0;
  dx = x1 - x0; dy = y1 - y0;
  glColor3f(1.0f, 1.0f, 0.0f);
  glPointSize(1);
  if(dx>dy)
  {
    d=dx-2*dy;
    UpIncre=2*dx-2*dy;
    DownIncre=-2*dy;
    while(x<=x1)
    {
      glBegin(GL_POINTS);
      glVertex2i(x,y);
      glEnd();
      x++;
      if(d<0)
      {
        y++;
        d+=UpIncre;
      }
      else
        d+=DownIncre;
    }
  }
}
void myDisplay(void)
{
  glClear(GL_COLOR_BUFFER_BIT);
  glColor3f(1.0f, 0.0f, 0.0f);
  glRectf(25.0, 25.0, 75.0, 75.0);
  glPointSize(5);
  glBegin(GL_POINTS);
  glColor3f(0.0f, 1.0f, 0.0f);  glVertex2f(0.0f, 0.0f);
  glEnd();
  MidBresenhamLine(0,0,300,200);
  glFlush();
}
void Init()
{
  glClearColor(0.0, 0.0, 0.0, 0.0);
  glShadeModel(GL_FLAT);
}
void Reshape(int w, int h)
{
  glViewport(0, 0, (GLsizei)w, (GLsizei)h);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluOrtho2D(0.0, 400.0, 0.0, 400.0);
}
int main(int argc, char * argv[])
{
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);
  glutInitWindowPosition(100, 100);
  glutInitWindowSize(600, 600);
  glutCreateWindow("Hello World!");
  Init();
  glutDisplayFunc(myDisplay);
  glutReshapeFunc(Reshape);
  glutMainLoop();
  return 0;
}

      image.gif

      要求：

      示范代码给出了0<k<1的Bresenham算法，要求将代码补充完整，实现所有直线的Bresenham算法。

      3.Cohen-Surtherland直线裁剪算法

      #include <gl/glut.h>
#include <stdio.h>
#include <stdlib.h>
#define LEFT_EDGE 1
#define RIGHT_EDGE 2
#define BOTTOM_EDGE 4
#define TOP_EDGE 8
void LineGL(int x0, int y0, int x1, int y1)
{
  glBegin(GL_LINES);
  glColor3f(1.0f, 0.0f, 0.0f); glVertex2f(x0, y0);
  glColor3f(0.0f, 1.0f, 0.0f); glVertex2f(x1, y1);
  glEnd();
}
struct Rectangle
{
  float xmin, xmax, ymin, ymax;
};
Rectangle rect;
int x0, y0, x1, y1;
int CompCode(int x, int y, Rectangle rect)
{
  int code = 0x00;
  if (y < rect.ymin)
    code = code | 4;
  if (y > rect.ymax)
    code = code | 8;
  if (x > rect.xmax)
    code = code | 2;
  if (x < rect.xmin)
    code = code | 1;
  return code;
}
int cohensutherlandlineclip(Rectangle rect, int &x0, int &y0, int &x1, int &y1)
{
  int accept, done;
  float x, y;
  accept = 0;
  done = 0;
  int code0, code1, codeout;
  code0 = CompCode(x0, y0, rect);
  code1 = CompCode(x1, y1, rect);
  do {
    if (!(code0 | code1))
    {
      accept = 1;
      done = 1;
    }
    else if (code0 & code1)
      done = 1;
    else
    {
      if (code0 != 0)
        codeout = code0;
      else
        codeout = code1;
      if (codeout&LEFT_EDGE) {
        y = y0 + (y1 - y0)*(rect.xmin - x0) / (x1 - x0);
        x = (float)rect.xmin;
      }
      else if (codeout&RIGHT_EDGE) {
        y = y0 + (y1 - y0)*(rect.xmax - x0) / (x1 - x0);
        x = (float)rect.xmax;
      }
      else if (codeout&BOTTOM_EDGE) {
        x = x0 + (x1 - x0)*(rect.ymin - y0) / (y1 - y0);
        y = (float)rect.ymin;
      }
      else if (codeout&TOP_EDGE) {
        x = x0 + (x1 - x0)*(rect.ymax - y0) / (y1 - y0);
        y = (float)rect.ymax;
      }
      if (codeout == code0)
      {
        x0 = x; y0 = y;
        code0 = CompCode(x0, y0, rect);
      }
      else
      {
        x1 = x; y1 = y;
        code1 = CompCode(x1, y1, rect);
      }
    }
  } while (!done);
  if (accept)
    LineGL(x0, y0, x1, y1);
  return accept;
}
void myDisplay()
{
  glClear(GL_COLOR_BUFFER_BIT);
  glColor3f(1.0f, 0.0f, 0.0f);
  glRectf(rect.xmin, rect.ymin, rect.xmax, rect.ymax);
  LineGL(x0, y0, x1, y1);
  glFlush();
}
void Init()
{
  glClearColor(0.0, 0.0, 0.0, 0.0);
  glShadeModel(GL_FLAT);
  rect.xmin = 100;
  rect.xmax = 300;
  rect.ymin = 100;
  rect.ymax = 300;
  x0 = 450, y0 = 0, x1 = 0, y1 = 450;
  printf("Press key 'c' to clip!\nPress key 'r' to Restore!\n");
}
void Reshape(int w, int h)
{
  glViewport(0, 0, (GLsizei)w, (GLsizei)h);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluOrtho2D(0.0, (GLdouble)w, 0.0, (GLdouble)h);
}
void keyboard(unsigned char key, int x, int y)
{
  switch (key)
  {
  case 'c':
    cohensutherlandlineclip(rect, x0, y0, x1, y1);
    glutPostRedisplay();
    break;
  case 'r':
    Init();
    glutPostRedisplay();
    break;
  case 'x':
    exit(0);
    break;
  default:
    break;
  }
}
int main(int argc, char *argv[])
{
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);
  glutInitWindowPosition(100, 100);
  glutInitWindowSize(640, 480);
  glutCreateWindow("Hello world!");
  Init();
  glutDisplayFunc(myDisplay);
  glutReshapeFunc(Reshape);
  glutKeyboardFunc(keyboard);
  glutMainLoop();
  return 0;
}

      image.gif

      要求：

      请分别给出直线的三种不同位置情况，测试实验代码是否存在问题，如果有请调试改正。

      4.选做题：实现Liang-Barsky裁剪算法。

      四、实验代码

      1.

      //DDA算法
#include <GL/glut.h>
void LineDDA(int x0, int y0, int x1, int y1)
{
  float x, dy, dx, y;
  float m;
  dx = x1 - x0;
  dy = y1 - y0;
  m = dy / dx;
  y = y0;
  glColor3f(1.0f, 1.0f, 0.0f);
  glPointSize(1);
  for (x = x0; x <= x1; x++)
  {
    glBegin(GL_POINTS);
    glVertex2i(x, (int)(y + 0.5));
    glEnd();
    y += m;
  }
}
void myDisplay(void)
{
  glClear(GL_COLOR_BUFFER_BIT);
  glColor3f(1.0f, 0.0f, 0.0f);
  glRectf(25.0, 25.0, 75.0, 75.0);
  glPointSize(5);
  glBegin(GL_POINTS);
  glColor3f(0.0f, 1.0f, 0.0f);  glVertex2f(0.0f, 0.0f);
  glEnd();
  LineDDA(0, 0, 200, 300);
  glBegin(GL_LINES);
  glColor3f(1.0f, 0.0f, 0.0f); glVertex2f(100.0f, 0.0f);
  glColor3f(0.0f, 1.0f, 0.0f); glVertex2f(180.0f, 240.0f);
  glEnd();
  glFlush();
}
void Init()
{
  glClearColor(0.0, 0.0, 0.0, 0.0);
  glShadeModel(GL_FLAT);
}
void Reshape(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(Reshape);
  glutMainLoop();
  return 0;
}

      image.gif

      2.

      //# include "stdafx.h"
# include <GL/glut.h>
# include <windows.h>
# include <math.h>
void MidBresenhamLine(int x0, int y0, int x1, int y1)
{
  int dx, dy, d, UpIncre, DownIncre, x, y;
  if (x0 > x1)
  {
    x = x1; x1 = x0; x0 = x;
    y = y1; y1 = y0; y0 = y;
  }
  x = x0; y = y0;
  dx = x1 - x0; dy = y1 - y0;
  glColor3f(1.0f, 1.0f, 0.0f);
  glPointSize(1);
  if (dx > dy)
  {
    d = dx - 2 * dy;
    UpIncre = 2 * dx - 2 * dy;
    DownIncre = -2 * dy;
    while (x <= x1)
    {
      glBegin(GL_POINTS);
      glVertex2i(x, y);
      glEnd();
      x++;
      if (d < 0)
      {
        y++;
        d += UpIncre;
      }
      else
        d += DownIncre;
    }
  }
  else {
    d = dy - 2 * dx;
    UpIncre = 2 * dy - 2 * dx;
    DownIncre = -2 * dx;
    while (y <= y1)
    {
      glBegin(GL_POINTS);
      glVertex2i(x, y);
      glEnd();
      y++;
      if (d < 0)
      {
        x++;
        d += UpIncre;
      }
      else
        d += DownIncre;
    }
  }
}
void myDisplay(void)
{
  glClear(GL_COLOR_BUFFER_BIT);
  glColor3f(1.0f, 0.0f, 0.0f);
  glRectf(25.0, 25.0, 75.0, 75.0);
  glPointSize(5);
  glBegin(GL_POINTS);
  glColor3f(0.0f, 1.0f, 0.0f);  glVertex2f(0.0f, 0.0f);
  glEnd();
  MidBresenhamLine(0, 0, 200, 300);
  glFlush();
}
void Init()
{
  glClearColor(0.0, 0.0, 0.0, 0.0);
  glShadeModel(GL_FLAT);
}
void Reshape(int w, int h)
{
  glViewport(0, 0, (GLsizei)w, (GLsizei)h);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluOrtho2D(0.0, 400.0, 0.0, 400.0);
}
int main(int argc, char* argv[])
{
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);
  glutInitWindowPosition(100, 100);
  glutInitWindowSize(600, 600);
  glutCreateWindow("Hello World!");
  Init();
  glutDisplayFunc(myDisplay);
  glutReshapeFunc(Reshape);
  glutMainLoop();
  return 0;
}

      image.gif

      3.

      #include <gl/glut.h>
#include <stdio.h>
#include <stdlib.h>
#define LEFT_EDGE 1
#define RIGHT_EDGE 2
#define BOTTOM_EDGE 4
#define TOP_EDGE 8
void LineGL(int x0, int y0, int x1, int y1)
{
  glBegin(GL_LINES);
  glColor3f(1.0f, 0.0f, 0.0f); glVertex2f(x0, y0);
  glColor3f(0.0f, 1.0f, 0.0f); glVertex2f(x1, y1);
  glEnd();
}
struct Rectangle
{
  float xmin, xmax, ymin, ymax;
};
struct Rectangle rect;
int x0, y0, x1, y1;
int CompCode(int x, int y, struct Rectangle rect)
{
  int code = 0x00;
  if (y < rect.ymin)
    code = code | 4;
  if (y > rect.ymax)
    code = code | 8;
  if (x > rect.xmax)
    code = code | 2;
  if (x < rect.xmin)
    code = code | 1;
  return code;
}
int cohensutherlandlineclip(struct Rectangle rect, int& x0, int& y0, int& x1, int& y1)
{
  int accept, done;
  float x, y;
  accept = 0;
  done = 0;
  int code0, code1, codeout;
  code0 = CompCode(x0, y0, rect);
  code1 = CompCode(x1, y1, rect);
  do {
    if (!(code0 | code1))
    {
      accept = 1;
      done = 1;
    }
    else if (code0 & code1)
      done = 1;
    else
    {
      if (code0 != 0)
        codeout = code0;
      else
        codeout = code1;
      if (codeout & LEFT_EDGE) {
        y = y0 + (y1 - y0) * (rect.xmin - x0) / (x1 - x0);
        x = (float)rect.xmin;
      }
      else if (codeout & RIGHT_EDGE) {
        y = y0 + (y1 - y0) * (rect.xmax - x0) / (x1 - x0);
        x = (float)rect.xmax;
      }
      else if (codeout & BOTTOM_EDGE) {
        x = x0 + (x1 - x0) * (rect.ymin - y0) / (y1 - y0);
        y = (float)rect.ymin;
      }
      else if (codeout & TOP_EDGE) {
        x = x0 + (x1 - x0) * (rect.ymax - y0) / (y1 - y0);
        y = (float)rect.ymax;
      }
      if (codeout == code0)
      {
        x0 = x; y0 = y;
        code0 = CompCode(x0, y0, rect);
      }
      else
      {
        x1 = x; y1 = y;
        code1 = CompCode(x1, y1, rect);
      }
    }
  } while (!done);
  if (accept)
    LineGL(x0, y0, x1, y1);
  else {
    x0 = 0; y = 0; x1 = 0; y1 = 0;
    LineGL(x0, y0, x1, y1);
  }
  return accept;
}
void myDisplay()
{
  glClear(GL_COLOR_BUFFER_BIT);
  glColor3f(1.0f, 0.0f, 0.0f);
  glRectf(rect.xmin, rect.ymin, rect.xmax, rect.ymax);
  LineGL(x0, y0, x1, y1);
  glFlush();
}
void Init()
{
  glClearColor(0.0, 0.0, 0.0, 0.0);
  glShadeModel(GL_FLAT);
  rect.xmin = 100;
  rect.xmax = 300;
  rect.ymin = 100;
  rect.ymax = 300;
  x0 = 0, y0 = 450, x1 = 400, y1 = 40;
  printf("Press key 'c' to clip!\nPress key 'r' to Restore!\n");
}
void Reshape(int w, int h)
{
  glViewport(0, 0, (GLsizei)w, (GLsizei)h);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluOrtho2D(0.0, (GLdouble)w, 0.0, (GLdouble)h);
}
void keyboard(unsigned char key, int x, int y)
{
  switch (key)
  {
  case 'c':
    cohensutherlandlineclip(rect, x0, y0, x1, y1);
    glutPostRedisplay();
    break;
  case 'r':
    Init();
    glutPostRedisplay();
    break;
  case 'x':
    exit(0);
    break;
  default:
    break;
  }
}
int main(int argc, char* argv[])
{
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);
  glutInitWindowPosition(100, 100);
  glutInitWindowSize(640, 480);
  glutCreateWindow("Hello world!");
  Init();
  glutDisplayFunc(myDisplay);
  glutReshapeFunc(Reshape);
  glutKeyboardFunc(keyboard);
  glutMainLoop();
  return 0;
}

      image.gif

      4.

      #include <windows.h>
#include <GL/glut.h>
#include <math.h>
#include<stdio.h>
#include <iostream>
float xmin, xmax, ymin, ymax;
using namespace std;
void myinit(void)
{
  glShadeModel(GL_FLAT);
  glClearColor(1.0, 1.0, 1.0, 0.0);
}
void myReshape(int w, int h)
{
  glViewport(0, 0, w, h);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  if (w <= h)
    gluOrtho2D(0.0, 1.0, 0.0, 1.0 * (GLfloat)h / (GLfloat)w);
  else
    gluOrtho2D(0.0, 1.0 * (GLfloat)w / (GLfloat)h, 0.0, 1.0);
  glMatrixMode(GL_MODELVIEW);
}
int Clip(float p, float q, float* tL, float* tU)
{
  int flag = 1;/*flag为标志变量0表示舍弃1表示可见*/
  float r;
  if (p < 0.0)
  {
    r = q / p;
    if (r > *tU)
      flag = 0;
    else if (r > *tL) {
      *tL = r;/*m取进入点最大参数值*/
    }
  }
  else if (p > 0.0) {
    r = q / p;
    if (r < *tL)
      flag = 0;
    else if (r < *tU) {
      *tU = r;/*n取离开点的最小值*/
    }
  }
  else if (q < 0 && p == 0) //平行于边界而且在界外的线 
    flag = 0;
  return flag;
}
void myclip()
// line clipping algorithm 
{
  float dx, dy, x1, tL, tU, x2, y1, y2;
  tL = 0, tU = 1.0;
  printf("请输入线段的两个顶点坐标x1,y1,x2,y2:\n");
  //scanf("%f%f%f%f", &x1, &y1, &x2, &y2);
  cin >> x1 >> y1 >> x2 >> y2;
  glBegin(GL_LINES);
  glColor4f(0.0, 0.0, 0.0, 0.0);
  glVertex2f(x1, y1); // line startpoint 
  glVertex2f(x2, y2); // line endpoint 
  glEnd();
  dx = x2 - x1;
  if (Clip(-dx, x1 - xmin, &tL, &tU))
    if (Clip(dx, xmax - x1, &tL, &tU)) {
      dy = y2 - y1;
      if (Clip(-dy, y1 - ymin, &tL, &tU))
        if (Clip(dy, ymax - y1, &tL, &tU))
        {
          if (tU < 1.0)
          {
            x2 = x1 + tU * dx;//通过n求得裁剪后的p2端点 
            y2 = y1 + tU * dy;
          }
          if (tL > 0.0)
          {
            x1 = x1 + tL * dx;//通过m求得裁剪后的p1端点 
            y1 = y1 + tL * dy;
          }
          glBegin(GL_LINES);
          glColor4f(1.0, 0.0, 0.0, 1.0);
          glVertex2f(x1, y1); // clipped line startpoint 
          glVertex2f(x2, y2); // clipped line endpoint 
          glEnd();
        }
    }
}
void display(void)
{
  glClear(GL_COLOR_BUFFER_BIT);
  printf("请分别输入矩形的左右下上边界：\n");
  //scanf("%f%f%f%f", &xmin, &xmax, &ymin, &ymax);
  cin >> xmin >> xmax >> ymin >> ymax;
  glColor4f(1.0, 1.0, 0.0, 0.75);
  glBegin(GL_POLYGON);
  glVertex2f(xmin, ymin); // Bottom Left
  glVertex2f(xmax, ymin); // Bottom Left
  glVertex2f(xmax, ymax); // Bottom Right
  glVertex2f(xmin, ymax); // Bottom Right
  glEnd();
  myclip();
  glFlush();
}
/*  Main Loop
 *  Open window with initial window size, title bar,
 *  RGBA display mode, and handle input events.
 */
int main(int argc, char** argv)
{
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
  //define size and the relative positon of the applicaiton window on the display
  glutInitWindowSize(500, 500);
  glutInitWindowPosition(100, 100);
  //init the defined window with "argv[1]" as topic showed on the top the window
  glutCreateWindow(argv[0]);
  // opengl setup
  myinit();
  //define callbacks
  glutDisplayFunc(display);
  glutReshapeFunc(myReshape);
  //enter the loop for display
  glutMainLoop();
  return 1;
}

      image.gif

      五、实验结果与心得

      1.

      image.gif编辑

      2.

      image.gif编辑image.gif编辑image.gif编辑

      3.

      image.gif编辑image.gif编辑

      image.gif编辑image.gif编辑

      image.gif编辑image.gif编辑

      4.

      image.gif编辑

      本次实验对DDA和Bresenham算法进行调试，实现了直线的光栅化；以及直线裁剪算法Cohen-Surtherland和Liang-Barsky裁剪算法，通过代码进行修改、调试运行，最终实现直线的裁剪。通过此次实验，学习了使用不同的算法实现直线的光栅化和裁剪，收获颇多，对图形学的知识有了进一步的学习。

      文章标签：
      云数据库 Tair（兼容 Redis）
      图形学
      算法
      关键词：
      算法实验
      算法编程
      计算机图形学算法
      实验算法
      算法计算机图形学
      相关实践学习
      基于Redis实现在线游戏积分排行榜
      本场景将介绍如何基于Redis数据库实现在线游戏中的游戏玩家积分排行榜功能。
      云数据库 Redis 版使用教程
      云数据库Redis版是兼容Redis协议标准的、提供持久化的内存数据库服务，基于高可靠双机热备架构及可无缝扩展的集群架构，满足高读写性能场景及容量需弹性变配的业务需求。 产品详情：https://www.aliyun.com/product/kvstore &nbsp; &nbsp; ------------------------------------------------------------------------- 阿里云数据库体验：数据库上云实战 开发者云会免费提供一台带自建MySQL的源数据库&nbsp;ECS 实例和一台目标数据库&nbsp;RDS实例。跟着指引，您可以一步步实现将ECS自建数据库迁移到目标数据库RDS。 点击下方链接，领取免费ECS&amp;RDS资源，30分钟完成数据库上云实战！https://developer.aliyun.com/adc/scenario/51eefbd1894e42f6bb9acacadd3f9121?spm=a2c6h.13788135.J_3257954370.9.4ba85f24utseFl
      56bnlrbj3zqum
      目录
      相关文章
      龙大吉
      |
      8天前
      |
      算法 Python
      在Python编程中，分治法、贪心算法和动态规划是三种重要的算法。分治法通过将大问题分解为小问题，递归解决后合并结果
      在Python编程中，分治法、贪心算法和动态规划是三种重要的算法。分治法通过将大问题分解为小问题，递归解决后合并结果；贪心算法在每一步选择局部最优解，追求全局最优；动态规划通过保存子问题的解，避免重复计算，确保全局最优。这三种算法各具特色，适用于不同类型的问题，合理选择能显著提升编程效率。
      龙大吉
      25 2
      java冯坚持
      |
      1月前
      |
      算法 搜索推荐 Java
      java 后端 使用 Graphics2D 制作海报，画echarts图，带工具类，各种细节：如头像切割成圆形，文字换行算法（完美实验success），解决画上文字、图片后不清晰问题
      这篇文章介绍了如何使用Java后端技术，结合Graphics2D和Echarts等工具，生成包含个性化信息和图表的海报，并提供了详细的代码实现和GitHub项目链接。
      java冯坚持
      104 0
      java 后端 使用 Graphics2D 制作海报，画echarts图，带工具类，各种细节：如头像切割成圆形，文字换行算法（完美实验success），解决画上文字、图片后不清晰问题
      java冯坚持
      |
      1月前
      |
      存储 缓存 分布式计算
      数据结构与算法学习一：学习前的准备，数据结构的分类，数据结构与算法的关系，实际编程中遇到的问题，几个经典算法问题
      这篇文章是关于数据结构与算法的学习指南，涵盖了数据结构的分类、数据结构与算法的关系、实际编程中遇到的问题以及几个经典的算法面试题。
      java冯坚持
      29 0
      数据结构与算法学习一：学习前的准备，数据结构的分类，数据结构与算法的关系，实际编程中遇到的问题，几个经典算法问题
      Codelinghu
      |
      1月前
      |
      算法
      计科一二班算法数据结构实验9答案
      计科一二班算法数据结构实验9答案
      Codelinghu
      14 0
      bruce刘晓伟-18435
      |
      1月前
      |
      算法 Python
      Python算法编程：冒泡排序、选择排序、快速排序
      Python算法编程：冒泡排序、选择排序、快速排序
      bruce刘晓伟-18435
      25 0
      热爱技术的小郑
      |
      3月前
      |
      算法 Java 测试技术
      算法分析（蛮力法与减治算法应用实验报告）
      这篇文章是关于算法分析的实验报告，介绍了如何使用蛮力法解决背包问题，并通过伪代码和Java代码实现，同时分析了其时间效率；还介绍了基于减治法思想实现的二叉查找树的插入与查找，同样提供了伪代码、Java源代码实现和时间效率分析，最后展示了测试结果截图。
      热爱技术的小郑
      35 1
      算法分析（蛮力法与减治算法应用实验报告）
      热爱技术的小郑
      |
      3月前
      |
      机器学习/深度学习 算法 Java
      算法设计（动态规划应用实验报告）实现基于贪婪技术思想的Prim算法、Dijkstra算法
      这篇文章介绍了基于贪婪技术思想的Prim算法和Dijkstra算法，包括它们的伪代码描述、Java源代码实现、时间效率分析，并展示了算法的测试用例结果，使读者对贪婪技术及其应用有了更深入的理解。
      热爱技术的小郑
      64 0
      算法设计（动态规划应用实验报告）实现基于贪婪技术思想的Prim算法、Dijkstra算法
      热爱技术的小郑
      |
      3月前
      |
      算法 Java 测试技术
      算法设计（动态规划实验报告） 基于动态规划的背包问题、Warshall算法和Floyd算法
      这篇文章介绍了基于动态规划法的三种算法：解决背包问题的递归和自底向上实现、Warshall算法和Floyd算法，并提供了它们的伪代码、Java源代码实现以及时间效率分析。
      热爱技术的小郑
      68 0
      算法设计（动态规划实验报告） 基于动态规划的背包问题、Warshall算法和Floyd算法
      请看我回答~
      |
      3月前
      |
      存储 算法 搜索推荐
      编程之旅中的算法启示
      【8月更文挑战第31天】在编程世界的迷宫里，算法是那把钥匙，它不仅能解锁问题的答案，还能引领我们深入理解计算机科学的灵魂。本文将通过一次个人的技术感悟旅程，探索算法的奥秘，分享如何通过实践和思考来提升编程技能，以及这一过程如何启示我们更深层次地认识技术与生活的交织。
      请看我回答~
      15 0
      热爱技术的小郑
      |
      3月前
      |
      算法 搜索推荐
      算法设计 （分治法应用实验报告）基于分治法的合并排序、快速排序、最近对问题
      这篇文章是关于分治法应用的实验报告，详细介绍了如何利用分治法实现合并排序和快速排序算法，并探讨了使用分治法解决二维平面上的最近对问题的方法，包括伪代码、源代码实现及时间效率分析，并附有运行结果和小结。
      热爱技术的小郑
      35 0

      热门文章

      最新文章

    1. 1
      18 回归算法 - Softmax回归 - 信贷审批案例
    2. 2
      [干货]基础机器学习算法
    3. 3
      泛型KMP算法
    4. 4
      【算法】算法之美—Fire Net
    5. 5
      A* + 弗洛伊德 算法 打造 360 向寻路 - [ActionScript3.0]
    6. 6
      【数据结构与算法】一篇文章彻底搞懂二分查找（思路图解+代码优化）两种实现方式，递归与非递归
    7. 7
      OneMob（一体传媒）：大数据算法 让营销更精准
    8. 8
      Node.js使用jsrsasign实现SHA256withRSA加密算法
    9. 9
      算法学习之顺序结构
    10. 10
      算法导论第十四章 数据结构的扩张
    11. 1
      算法金 | 深度学习图像增强方法总结
      143
    12. 2
      基于内容的推荐系统算法详解
      198
    13. 3
      基于GA遗传优化算法的Okumura-Hata信道参数估计算法matlab仿真
      68
    14. 4
      强化学习系列：A3C算法解析
      213
    15. 5
      AES（Advanced Encryption Standard）是一种广泛使用的对称密钥加密算法，由美国国家标准技术研究所（NIST）制定。
      99
    16. 6
      计算机视觉：目标检测算法综述
      151
    17. 7
      `scipy.optimize`模块提供了许多用于优化问题的函数和算法。这些算法可以用于找到函数的最小值、最大值、零点等。
      87
    18. 8
      Python排序算法大PK：归并VS快速，谁才是你的效率之选？
      36
    19. 9
      “解锁Python高级数据结构新姿势：图的表示与遍历，让你的算法思维跃升新高度
      40
    20. 10
      深入剖析操作系统调度算法
      57

      21. 相关课程

      更多
    21. 智能运维赛（复赛）：利用数据和算法，快速定位系统异常并进行根因分析
    22. 智能创作赛（复赛）：相册应用中的视频故事生成算法介绍
    23. 智能创作赛（初赛）：相册应用中的故事生成算法介绍
    24. 相册服务中的故事生成算法介绍
    25. Go语言核心编程 - 数据结构和算法
    26. 神经网络概览及算法详解

      27. 相关电子书

      更多
    27. 数据+算法定义新世界
    28. 袋鼠云基于实时计算的反黄牛算法
    29. Alink：基于Apache Flink的算法平台

      30. 相关实验场景

      更多
    30. 推荐系统入门之使用ALS算法实现打分预测
    31. 欧拉图的构造性证明与算法实现
    32. RSA密码算法设计与实现
    33. RSA非对称加密算法
    34. 使用Swing算法实现商品推荐
      35. 下一篇
      阿里云OSS设置跨域访问