用qt 写DDA ,Bresenham画线,中点圆和椭圆

最新推荐文章于 2024-03-04 14:52:55 发布
最新推荐文章于 2024-03-04 14:52:55 发布
阅读量1.1k 收藏 20
点赞数 2
文章标签： 图形学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sx_zy/article/details/112056959
版权

计算机图形学课内实验

用qt 写DDA ,Bresenham画线,中点圆和椭圆：

mainwindow.h：

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QPushButton>
#include <QTextEdit>
#include <QLabel>
namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();
    QPushButton BlineDDA;
    QPushButton BlineBre;
    QPushButton Bcircular;
    QPushButton Bellipse;

    QTextEdit TlineDDA_x1;
    QTextEdit TlineDDA_y1;
    QTextEdit TlineDDA_x2;
    QTextEdit TlineDDA_y2;

    QLabel TlineDDA1_x1;
    QLabel TlineDDA1_y1;
    QLabel TlineDDA1_x2;
    QLabel TlineDDA1_y2;

    QTextEdit TlineBre_x1;
    QTextEdit TlineBre_y1;
    QTextEdit TlineBre_x2;
    QTextEdit TlineBre_y2;

    QLabel TlineBre1_x1;
    QLabel TlineBre1_y1;
    QLabel TlineBre1_x2;
    QLabel TlineBre1_y2;

    QTextEdit Tcircular_x;
    QTextEdit Tcircular_y;
    QTextEdit Tcircular_r;

    QLabel Tcircular1_x;
    QLabel Tcircular1_y;
    QLabel Tcircular1_r;

    QTextEdit Tellipse_x;
    QTextEdit Tellipse_y;
    QTextEdit Tellipse_rx;
    QTextEdit Tellipse_ry;

    QLabel Tellipse1_x;
    QLabel Tellipse1_y;
    QLabel Tellipse1_rx;
    QLabel Tellipse1_ry;

    int board_x=1000;
    int board_y=1000;

    int button_x=100;
    int button_y=100;

    int text_x=100;
    int text_y=100;

    QTimer *timer;

    void paintEvent(QPaintEvent *);
    void setup();
    QPoint translate(int x,int y);
    int mode=0;
    int n;

    int translate_x(int x);
    int translate_y(int y);
    void exchange(int* a,int* b);
    int max(int a,int b);

private:
    Ui::MainWindow *ui;


};


#endif // MAINWINDOW_H

main.cpp:

#include "mainwindow.h"
#include <QApplication>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;
    w.show();

    return a.exec();
}

mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <QPushButton>
#include <QTextEdit>
#include <QPainter>
#include<QDebug>
#include <windows.h>
#include <QTime>
#include <QCoreApplication>
#include <math.h>
#include <QTimer>
#include <QLabel>
MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    setup();

    timer=new QTimer(this);
    timer->setInterval(10);
    connect(&BlineBre,&QPushButton::clicked,[=](){
        mode=1;
        int x1=translate_x(TlineBre_x1.toPlainText().toInt());
        int y1=translate_y(TlineBre_y1.toPlainText().toInt());
        int x2=translate_x(TlineBre_x2.toPlainText().toInt());
        int y2=translate_y(TlineBre_y2.toPlainText().toInt());
        int number=max(abs(x1-x2),abs(y1-y2));
        n=0;

        connect(timer,&QTimer::timeout,[=](){

               if(n<number)
               {
                   update();
                   n++;
               }
        });

    });
    connect(&BlineDDA,&QPushButton::clicked,[=](){
        mode=2;
        int x1=translate_x(TlineDDA_x1.toPlainText().toInt());
        int y1=translate_y(TlineDDA_y1.toPlainText().toInt());
        int x2=translate_x(TlineDDA_x2.toPlainText().toInt());
        int y2=translate_y(TlineDDA_y2.toPlainText().toInt());
        int number=max(abs(x1-x2),abs(y1-y2));
        n=0;

        connect(timer,&QTimer::timeout,[=](){

               if(n<number)
               {
                   update();
                   n++;
               }
        });


    });
    connect(&Bcircular,&QPushButton::clicked,[=](){
        mode=3;
        int number=2*Tcircular_r.toPlainText().toInt();
        n=0;
        connect(timer,&QTimer::timeout,[=](){

            if(n<number)
            {
                update();
                n++;
            }
        });
    });
    connect(&Bellipse,&QPushButton::clicked,[=](){
        mode=4;
        int number=Tellipse_rx.toPlainText().toInt()+Tellipse_ry.toPlainText().toInt();
        n=0;
        connect(timer,&QTimer::timeout,[=](){

            if(n<number)
            {
                update();
                n++;
            }
        });
    });
    timer->start();

}

void MainWindow::paintEvent(QPaintEvent *)
{
    QPainter painter(this);
    painter.drawLine(QPoint(0,board_y/2),QPoint(board_x,board_y/2));
    painter.drawLine(QPoint(board_x/2,0),QPoint(board_x/2,board_y));
    painter.drawText(QRect(board_x/2,board_y/2,board_x/2+50,board_y/2+25),"(0,0)");
    QPen pen(QColor(123,0,0));
    pen.setWidth(4);
    painter.setPen(pen);
    for(int i=0;i<=board_x;i+=20)
    {
        painter.drawPoint(i,0.5*board_y);
        painter.drawPoint(0.5*board_y,i);
    }
    pen.setColor(QColor(0,0,0));
    pen.setWidth(3);
    painter.setPen(pen);
    if(mode==0)
    {}
    else if(mode==1)
    {
        float x1=translate_x(TlineBre_x1.toPlainText().toInt());
        float y1=translate_y(TlineBre_y1.toPlainText().toInt());
        float x2=translate_x(TlineBre_x2.toPlainText().toInt());
        float y2=translate_y(TlineBre_y2.toPlainText().toInt());
        int num=0;
        float dy,dx,y,x,p;
        float m;
        dx=fabs(x2-x1);
        dy=fabs(y2-y1);
        m=(y2-y1)/(x2-x1);
        if(fabs(m)<1)
        {
            if(x1>x2)
            {
                x1=x2;
                y1=y2;
            }
            x=x1;
            y=y1;
            p=2*dy-dx;
            painter.drawPoint(x,y);
            for(int k=0;(k<dx)&&(num<n);k++)
            {
               if(p<0)
               {
                   p+=2*dy;

               }
               else
               {
                   p+=2*dy-2*dx;
                   qDebug()<<m;
                   y=(m>0)?y+1:y-1;

               }
               num++;x++;
               qDebug()<<p;
               painter.drawPoint(x,y);
            }
        }
        else
        {
            m=1/m;
            if(y1>y2)
            {
                y1=y2;
                x1=x2;
            }
            x=x1;
            y=y1;
            p=2*dx-dy;
            painter.drawPoint(x,y);
            for(int k=0;(k<dy)&&(num<n);k++)
            {
               if(p<0)
               {
                   p+=2*dx;

               }
               else
               {
                   p+=2*dx-2*dy;
                   qDebug()<<m;
                   x=(m>0)?x+1:x-1;
               }
               num++;y++;
               qDebug()<<p;
               painter.drawPoint(x,y);
            }
        }
    }
    else if(mode==2)
    {
        int x1=translate_x(TlineDDA_x1.toPlainText().toInt());
        int y1=translate_y(TlineDDA_y1.toPlainText().toInt());
        int x2=translate_x(TlineDDA_x2.toPlainText().toInt());
        int y2=translate_y(TlineDDA_y2.toPlainText().toInt());
        int num=0;
        float dy,dx,y,m,x;

        dx=x2-x1;
        dy=y2-y1;
        m=dy/dx;
        qDebug()<<m;
        if(fabs(m)<1)
        {
            y=y1;
            if(x1>x2)
            {
                y=y2;
                exchange(&x1,&x2);
                exchange(&y1,&y2);
            }
            for(x=x1;(x<=x2)&&(num<n);x++)
            {
               painter.drawPoint(x,int(y+0.5));
               y+=m;
               num++;
            }
        }
        else
        {
            m=1/m;
            x=x1;
            if(y1>y2)
            {
                x=x2;
                exchange(&x1,&x2);
                exchange(&y1,&y2);
            }
            for(y=y1;y<=y2&&(num<n);y++)
            {
               painter.drawPoint(int(x+0.5),y);
               x+=m;
               num++;
            }
        }
    }
    else if(mode==3)
    {
        int x_center=translate_x(Tcircular_x.toPlainText().toInt());
        int y_center=translate_y(Tcircular_y.toPlainText().toInt());
        int r=Tcircular_r.toPlainText().toInt();
        long p=1-r;
        int x=0;
        int y=r;
        int num=0;
               painter.drawPoint(x_center,y_center+r);
               painter.drawPoint(x_center,y_center-r);
               painter.drawPoint(x_center+r,y_center);
               painter.drawPoint(x_center-r,y_center);
               while(x<y&&num<n)
               {

                      if(p<0)
                      {
                             p+=2*x+3;
                      }
                      else
                      {
                             p+=2*x-2*y+5;
                             y--;
                      }
                      x++;num++;
                      painter.drawPoint(x_center+x,y_center+y);
                      painter.drawPoint(x_center-x,y_center-y);
                      painter.drawPoint(x_center+x,y_center-y);
                      painter.drawPoint(x_center-x,y_center+y);
                      painter.drawPoint(x_center+y,y_center+x);
                      painter.drawPoint(x_center-y,y_center-x);
                      painter.drawPoint(x_center+y,y_center-x);
                      painter.drawPoint(x_center-y,y_center+x);
               }
    }
    else if(mode==4)
    {
        int x_center=translate_x(Tellipse_x.toPlainText().toInt());
        int y_center=translate_y(Tellipse_y.toPlainText().toInt());
        int rx=Tellipse_rx.toPlainText().toInt();
        int ry=Tellipse_ry.toPlainText().toInt();
        long p=long(ry*ry+0.25*rx*rx-ry*rx*rx);
        int x=0;
        int y=ry;
        int num=0;
               painter.drawPoint(x_center,y_center+ry);
               painter.drawPoint(x_center,y_center-ry);
               while(ry*ry*x<rx*rx*y&&num<n)
               {

                      if(p<=0)
                      {
                             p+=ry*ry*(2*x+3);
                      }
                      else
                      {
                             p+=ry*ry*(2*x+3)+rx*rx*(-2*y+2);
                             y--;
                      }
                      x++;num++;
                      painter.drawPoint(x_center+x,y_center+y);
                      painter.drawPoint(x_center-x,y_center-y);
                      painter.drawPoint(x_center+x,y_center-y);
                      painter.drawPoint(x_center-x,y_center+y);

               }
               p=long(ry*ry*((x+0.5)*(x+0.5)-rx*rx))+long(rx*rx*(y-1)*(y-1));
               while(y>0&&num<n)
               {

                      if(p<=0)
                      {
                             p+=ry*ry*(2*x+2)+rx*rx*(-2*y+3);
                             x++;
                      }
                      else
                      {
                             p+=rx*rx*(-2*y+3);
                      }
                      y--;num++;
                      painter.drawPoint(x_center+x,y_center+y);
                      painter.drawPoint(x_center-x,y_center-y);
                      painter.drawPoint(x_center+x,y_center-y);
                      painter.drawPoint(x_center-x,y_center+y);
               }
    }
}

void MainWindow::setup()
{
    resize(board_x+button_x+text_x+300,board_y);

    BlineBre.setParent(this);
    BlineBre.setText("Bresenham画线");
    BlineBre.move(board_x,400);
    BlineBre.setStyleSheet("text-align: left;");
    BlineBre.setFixedSize(150,50);

    BlineDDA.setParent(this);
    BlineDDA.setText("DDA画线");
    BlineDDA.move(board_x,button_y/2+400);
    BlineDDA.setStyleSheet("text-align: left;");
    BlineDDA.setFixedSize(150,50);

    Bcircular.setParent(this);
    Bcircular.setText("circular画圆");
    Bcircular.move(board_x,2*button_y/2+400);
    Bcircular.setStyleSheet("text-align: left;");
    Bcircular.setFixedSize(150,50);

    Bellipse.setParent(this);
    Bellipse.setText("ellipse椭圆");
    Bellipse.move(board_x,3*button_y/2+400);
    Bellipse.setStyleSheet("text-align: left;");
    Bellipse.setFixedSize(150,50);

    TlineDDA1_x1.setParent(this);
    TlineDDA1_x1.resize(50,50);
    TlineDDA1_x1.setText("x1");
    TlineDDA1_x1.move(board_x+button_x+60,400);
    TlineDDA1_y1.setParent(this);
    TlineDDA1_y1.resize(50,50);
    TlineDDA1_y1.setText("y1");
    TlineDDA1_y1.move(board_x+button_x+140,400);
    TlineDDA1_x2.setParent(this);
    TlineDDA1_x2.resize(50,50);
    TlineDDA1_x2.setText("x2");
    TlineDDA1_x2.move(board_x+button_x+220,400);
    TlineDDA1_y2.setParent(this);
    TlineDDA1_y2.resize(50,50);
    TlineDDA1_y2.setText("y2");
    TlineDDA1_y2.move(board_x+button_x+300,400);

    TlineBre_x1.setParent(this);
    TlineBre_x1.resize(50,50);
    TlineBre_x1.move(board_x+button_x+80,400);
    TlineBre_y1.setParent(this);
    TlineBre_y1.resize(50,50);
    TlineBre_y1.move(board_x+button_x+160,400);
    TlineBre_x2.setParent(this);
    TlineBre_x2.resize(50,50);
    TlineBre_x2.move(board_x+button_x+240,400);
    TlineBre_y2.setParent(this);
    TlineBre_y2.resize(50,50);
    TlineBre_y2.move(board_x+button_x+320,400);


    TlineBre1_x1.setParent(this);
    TlineBre1_x1.resize(50,50);
    TlineBre1_x1.setText("x1");
    TlineBre1_x1.move(board_x+button_x+60,button_y/2+400);
    TlineBre1_y1.setParent(this);
    TlineBre1_y1.resize(50,50);
    TlineBre1_y1.setText("y1");
    TlineBre1_y1.move(board_x+button_x+140,button_y/2+400);
    TlineBre1_x2.setParent(this);
    TlineBre1_x2.resize(50,50);
    TlineBre1_x2.setText("x2");
    TlineBre1_x2.move(board_x+button_x+220,button_y/2+400);
    TlineBre1_y2.setParent(this);
    TlineBre1_y2.resize(50,50);
    TlineBre1_y2.setText("y2");
    TlineBre1_y2.move(board_x+button_x+300,button_y/2+400);

    TlineDDA_x1.setParent(this);
    TlineDDA_x1.resize(50,50);
    TlineDDA_x1.move(board_x+button_x+80,button_y/2+400);
    TlineDDA_y1.setParent(this);
    TlineDDA_y1.resize(50,50);
    TlineDDA_y1.move(board_x+button_x+160,button_y/2+400);
    TlineDDA_x2.setParent(this);
    TlineDDA_x2.resize(50,50);
    TlineDDA_x2.move(board_x+button_x+240,button_y/2+400);
    TlineDDA_y2.setParent(this);
    TlineDDA_y2.resize(50,50);
    TlineDDA_y2.move(board_x+button_x+320,button_y/2+400);

    Tcircular1_x.setParent(this);
    Tcircular1_x.resize(50,50);
    Tcircular1_x.setText("x");
    Tcircular1_x.move(board_x+button_x+60,2*button_y/2+400);
    Tcircular1_y.setParent(this);
    Tcircular1_y.resize(50,50);
    Tcircular1_y.setText("y");
    Tcircular1_y.move(board_x+button_x+140,2*button_y/2+400);
    Tcircular1_r.setParent(this);
    Tcircular1_r.resize(50,50);
    Tcircular1_r.setText("r");
    Tcircular1_r.move(board_x+button_x+220,2*button_y/2+400);

    Tcircular_x.setParent(this);
    Tcircular_x.resize(50,50);
    Tcircular_x.move(board_x+button_x+80,2*button_y/2+400);
    Tcircular_y.setParent(this);
    Tcircular_y.resize(50,50);
    Tcircular_y.move(board_x+button_x+160,2*button_y/2+400);
    Tcircular_r.setParent(this);
    Tcircular_r.resize(50,50);
    Tcircular_r.move(board_x+button_x+240,2*button_y/2+400);


    Tellipse1_x.setParent(this);
    Tellipse1_x.resize(50,50);
    Tellipse1_x.setText("x");
    Tellipse1_x.move(board_x+button_x+60,3*button_y/2+400);
    Tellipse1_y.setParent(this);
    Tellipse1_y.resize(50,50);
    Tellipse1_y.setText("y");
    Tellipse1_y.move(board_x+button_x+140,3*button_y/2+400);
    Tellipse1_rx.setParent(this);
    Tellipse1_rx.resize(50,50);
    Tellipse1_rx.setText("rx");
    Tellipse1_rx.move(board_x+button_x+220,3*button_y/2+400);
    Tellipse1_ry.setParent(this);
    Tellipse1_ry.resize(50,50);
    Tellipse1_ry.setText("ry");
    Tellipse1_ry.move(board_x+button_x+300,3*button_y/2+400);

    Tellipse_x.setParent(this);
    Tellipse_x.resize(50,50);
    Tellipse_x.move(board_x+button_x+80,3*button_y/2+400);
    Tellipse_y.setParent(this);
    Tellipse_y.resize(50,50);
    Tellipse_y.move(board_x+button_x+160,3*button_y/2+400);
    Tellipse_rx.setParent(this);
    Tellipse_rx.resize(50,50);
    Tellipse_rx.move(board_x+button_x+240,3*button_y/2+400);
    Tellipse_ry.setParent(this);
    Tellipse_ry.resize(50,50);
    Tellipse_ry.move(board_x+button_x+320,3*button_y/2+400);
}

QPoint MainWindow::translate(int x,int y)
{
    QPoint p;
    p.setX(x+board_x/2);
    p.setY(board_y/2-y);
    return p;
}

int MainWindow::translate_x(int x)
{
    int x_=x+board_x/2;
    return x_;
}

int MainWindow::translate_y(int y)
{
    int y_=board_y/2-y;
    return y_;
}

void MainWindow::exchange(int* a,int* b)
{
    int temp;
    temp=*a;
    *a=*b;
    *b=temp;
}

int MainWindow::max(int a,int b)
{
    return (a>b)?a:b;
}

MainWindow::~MainWindow()
{
    delete ui;
}
brent-zyy
关注
  • 2
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
计算机图形学作业一。Bresenham直线画线算法，中点圆、中点椭圆算法&可视化（Python3+PyQt5）
布屿
03-24 3516
上机题目1: • 采用DDA/中点法/Bresenham算法画任意直线及(椭)圆。 要求: • 将象素网格表现出来，建立网格坐标系 • 用橡皮筋的形式输入参数 • 鼠标移动时，显示鼠标当前位置 选做： • 显示判别式的计算过程和下一点的选择策略 • 记录生成点的坐标，建议用表的形式 • 图形生成过程可以动态、重复的演示(回放) 第零步：因个人原因我决定用Python+PyCharm+Matplot...
c++（QT5）图形学-中点画圆（完整工程文件）
06-06
鼠标左右键和中键操作。可以用vs或QT creator打开。这是完整的项目文件夹，保证编译通过。 课上写的代码，非示例代码
QT Breseham画线
11-23
QT Breseham画线 QT Breseham画线 QT Breseham画线 QT Breseham画线 QT Breseham画线
QT实现中点画线法、DDA画线法及画圆和椭圆
06-27
QT实现DDA、中点画线法以及画圆和椭圆，点击画图按钮，然后在网格上拖动鼠标，实现画线程序，画圆和椭圆和画直线方法类似。上传的是成功运行后的QT工程文件的压缩包。
计算机图形学学习python实现2 （绘制圆和椭圆） （中点Bresenham画圆法）(完整代码为鼠标绘制)
最新发布
m0_72786913的博客
03-04 817
本文主要用python实现了用Bresenham画圆法绘制圆和椭圆，完整代码为用鼠标实时绘制图像。
c语言中点算法生成圆,圆生成算法（中点画圆、Bresenham画圆）
weixin_28921621的博客
05-24 1114
#include #include void MidPointCircle(int r, int color);void CirclePoints(int x,int y,int color);void BresenhamCircle(int xc,int yc,int r,int color);void plot_cicle_point(int xc,int yc,int x,int y,int...
中点画圆算法----计算机图形学
但行好事，莫问前程
10-08 4644
圆的对称特性： 一个八分圆上的点可以映射为其余七个八分圆的点 利用圆的对称性可以减少计算量，只需要计算出一个八分之一圆上需要画的点，就可以映射出整个圆 中点画圆算法： （对于原点为(xc,yc)的圆，假定圆心在坐标原点(0,0)的像素位置，把计算出每个圆上像素点(x,y)加到屏幕位置上，即(xc+x,yc+y)） 现在来具体研究如何从点（0，R）到 （, ）顺时...
计算机图形学实验
qq_44458671的博客
11-04 1255
实验一 利用DDA算法绘制直线 开发语言及实验环境 开发语言：C++ 实现平台：Microsoft Visual Studio 6.0 实验目的 熟悉开发环境，掌握计算机使用DDA绘制Bezier曲线的基本原理以及程序编写。 实验原理 DDA算法主要是利用了微分的思想，通过同时对x和y各增加一个小增量，计算下一步的x和y值 yi=kxi+by_i = kx_i + byi​=kxi​+b yi+1=kxi+1+b=kxi+b+k△x=yi+k△xy_{i+1} = kx_{i+1} + b = kx_i +
基于java使用DDA、Bresenham算法、中点画圆和椭圆、来实可视化界面画线功能
10-07
计算机图形学的作业；完成度非常高；有需要的可以下载
SDUWH计算机图形学实验--2020
10-22
2020--SDUWH--计算机图形学实验 共20个实验 实验1 直线的绘制 实验2 直线的DDA生成算法 实验3 直线中点生成算法 实验4 直线Bresenham生成算法 实验5 中点画圆算法 实验6 中点画椭圆算法 实验7 多边形有序边表算法 实验8 边标志多边形填充算法 实验9 种子填充算法 实验10 直线的裁剪 实验11 多边形的裁剪算法 实验12 Weiler-Athenton多边形裁剪算法 实验13 视窗 实验14 3D房屋绘制 实验15 金字塔 实验16 交互技术应用 实验17光照模型实例 实验18 阴影Shade 实验19 纹理实验 实验20 贝塞尔曲线
计算机图形学 DDA与Bresenham画线画圆
05-06
DDA 画线算法、中点 Bresenham 画线算法、中点画圆法、 Bresenham 画圆，交互式画线、画圆，鼠标跟随动态更新画线。
图形学圆的绘制（DDA算法和Bresenham算法）
09-17
圆的绘制（DDA算法和Bresenham算法）。
DDA算法画直线（计算机图形学）.zip
10-07
在 pycharm 加 pyqt5环境中开发，python实现 DDA算法 画直线。 有优美的 UI界面。
Qt4.6.2实现的图形学实验
01-05
用Qt实现的图形学实验，相较于传统的OpenGL版本，Qt版本更有活力，创造潜力更大，所有的项目文件都可以直接运行，下面是实验项目内容说明： 01linedraw：直线的绘制 02DDA：直线的DDA生成算法 03MidPaint：直线中点生成算法 04Bresenham：直线Bresenham生成算法 05DrawCircle：中点画圆算法 06DrawEllipse：中点画椭圆算法 07EdgeTablePolygon：多边形有序边表算法 08：边标志多边形填充算法 09SeedPolygon：种子填充算法 10clipline：直线的裁剪 11ClipPolygon：多边形的裁剪算法 NewWA：Weiler-Athenton多边形裁剪算法 13shichuangbianhuan：视窗变换 3Dhouse：3D房屋绘制 pyramid：金字塔 cg12_interaction：交互技术应用 欢迎大家下载、评论、批评指正
计算机图形学直线段的扫描转换C++实现（包含数值微分DDA， 中点画线法，Bresenham算法）
11-01
计算机图形学之直线段的扫描转换C++实现 包含DDA数值微分算法，中点画线法，Bresenham算法
图形学曲线_dda直线_椭圆画法_圆画法_bresenham绘制直线_
10-04
图形学绘制dda直线，bresenham直线，椭圆，圆，矩形和多边形
vc绘图源程序（DDA,bresenham，中点画线，圆）
03-23
本程序包含了DDA画线法 Breseham画线，画圆，椭圆源程序
中点Bresenham算法光栅化画直线（个人总结精简版）代码超短！速度极快！
weixin_30701575的博客
09-02 332
中点Bresenham算法光栅化画直线，每次只位移一个像素，精度高！此源码借助直线 y=x 做了一些转换，简化了主位移的处理，每次移动只需要 加减操作， 不需要乘除！速度极快！！ 原理在最后，下面先贴上核心代码~ void Bresenham_LineTo(CDC *pDC, int x1, int y1, int x2, int y2) //中点Bresenham算法 { float...
简述DDA画线算法和Bresenham画线算法的算法思想
06-07
DDA画线算法（Digital Differential Analyzer）和Bresenham画线算法都是计算机图形学中常用的画线算法。 DDA画线算法的思想是通过计算两个端点之间的斜率来决定每个像素点的位置，从而实现画线。具体而言，算法将直线分成若干段，每段的长度为一个单位像素，然后根据斜率计算每个像素点的坐标，并将其输出。这种算法简单易懂，但是由于每个像素点的计算都需要进行浮点运算，因此效率较低。 Bresenham画线算法的思想是通过计算直线的离散函数值来决定每个像素点的位置，从而实现画线。具体而言，算法根据直线的斜率和截距，沿着直线方向递增x轴坐标，然后利用离散函数计算出对应的y轴坐标。根据计算结果，算法判断离离散函数值最近的两个像素点哪个更接近直线，然后将更接近直线的像素点输出。这种算法避免了浮点运算，效率较高，但是只能画在第一象限内的线段。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值