计算机图形学

最新推荐文章于 2023-05-05 17:09:19 发布
最新推荐文章于 2023-05-05 17:09:19 发布
阅读量460 收藏
点赞数
文章标签： 算法 几何学 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/vmwarekali1/article/details/109014088
版权

圆和椭圆的画线算法

一、圆的画线算法

  1. 圆的中点画线算法
    原理：圆的中点画线算法主要是因为圆具有八对称的特性，因此只需要完成八分之一圆弧，然后将八分之一圆弧上的点以X，Y轴和Y=X这条直线进行对称操作。所以在此算法中，我们只需要对斜率k在[0,1]之间的八分之圆弧进行分析。
    过程：构造判别式在这里插入图片描述
    判断中点M与圆的位置关系，判别式的值<0在圆内,>0在圆外,=0在圆上
    在这里插入图片描述
    设d=F(M)=F(xp+1,yp-0.5)=(xp+1)2 +(yp-0.5)2 - r2
    当d<0时，M在圆内，取P1作为下一像素点；
    当d>0时，M在园外，取P2作为下一像素点；
    当d=0时，M在圆上，取任一点即可，这里我们取P2。
    确定了取点之后我们需要计算下一像素点的判别式d’：
    如果d<0,d’=F(xp+2,yp-0.5)=d+2xp+3
    反之d>=0，d’=F(xp+2,yp-1.5)=d+2    (xp-yp)+5
    因为第一个像素点为(0,r)，d的初始值为1.25-r

核心代码如下：

    //中点画圆算法
void CircleDraw_DDA() {
    int x, y;
    double d;
    x = 380;
    y = 380 + r;
    d = 12.5 - r;
    double x1 = x, y1, r1 = r;
    //描线
    while ((x1 - 380) <= r1) {
        y1 = sqrt(r1 * r1 - (x1 - 380) * (x1 - 380));
        line(x1, 380 + y1, x1, 380 + y1, RGB(0, 255, 0));
        line(x1, 380 - y1, x1, 380 - y1, RGB(0, 255, 0));
        x1 += 0.1;
    }
    while ((-x1 + 380) <= r1) {
        y1 = sqrt(r1 * r1 - (x1 - 380) * (x1 - 380));
        line(x1, 380 + y1, x1, 380 + y1, RGB(0, 255, 0));
        line(x1, 380 - y1, x1, 380 - y1, RGB(0, 255, 0));
        x1 -= 0.1;
    }
    //描点
    while (x <= y) {
        line(x - 2, y - 2, x + 2, y - 2, RGB(255, 0, 0));
        line(x - 2, y - 2, x - 2, y + 2, RGB(255, 0, 0));
        line(x - 2, y + 2, x + 2, y + 2, RGB(255, 0, 0));
        line(x + 2, y - 2, x + 2, y + 2, RGB(255, 0, 0));
        line(y - 2, x - 2, y + 2, x - 2, RGB(255, 0, 0));
        line(y - 2, x - 2, y - 2, x + 2, RGB(255, 0, 0));
        line(y - 2, x + 2, y + 2, x + 2, RGB(255, 0, 0));
        line(y + 2, x - 2, y + 2, x + 2, RGB(255, 0, 0));
        line(x - 2, 760 - y - 2, x + 2, 760 - y - 2, RGB(255, 0, 0));
        line(x - 2, 760 - y - 2, x - 2, 760 - y + 2, RGB(255, 0, 0));
        line(x - 2, 760 - y + 2, x + 2, 760 - y + 2, RGB(255, 0, 0));
        line(x + 2, 760 - y - 2, x + 2, 760 - y + 2, RGB(255, 0, 0));
        line(y - 2, 760 - x - 2, y + 2, 760 - x - 2, RGB(255, 0, 0));
        line(y - 2, 760 - x - 2, y - 2, 760 - x + 2, RGB(255, 0, 0));
        line(y - 2, 760 - x + 2, y + 2, 760 - x + 2, RGB(255, 0, 0));
        line(y + 2, 760 - x - 2, y + 2, 760 - x + 2, RGB(255, 0, 0));
        line(760 - x - 2, y - 2, 760 - x + 2, y - 2, RGB(255, 0, 0));
        line(760 - x - 2, y - 2, 760 - x - 2, y + 2, RGB(255, 0, 0));
        line(760 - x - 2, y + 2, 760 - x + 2, y + 2, RGB(255, 0, 0));
        line(760 - x + 2, y - 2, 760 - x + 2, y + 2, RGB(255, 0, 0));
        line(760 - y - 2, x - 2, 760 - y + 2, x - 2, RGB(255, 0, 0));
        line(760 - y - 2, x - 2, 760 - y - 2, x + 2, RGB(255, 0, 0));
        line(760 - y - 2, x + 2, 760 - y + 2, x + 2, RGB(255, 0, 0));
        line(760 - y + 2, x - 2, 760 - y + 2, x + 2, RGB(255, 0, 0));
        line(760 - x - 2, 760 - y - 2, 760 - x + 2, 760 - y - 2, RGB(255, 0, 0));
        line(760 - x - 2, 760 - y - 2, 760 - x - 2, 760 - y + 2, RGB(255, 0, 0));
        line(760 - x - 2, 760 - y + 2, 760 - x + 2, 760 - y + 2, RGB(255, 0, 0));
        line(760 - x + 2, 760 - y - 2, 760 - x + 2, 760 - y + 2, RGB(255, 0, 0));
        line(760 - y - 2, 760 - x - 2, 760 - y + 2, 760 - x - 2, RGB(255, 0, 0));
        line(760 - y - 2, 760 - x - 2, 760 - y - 2, 760 - x + 2, RGB(255, 0, 0));
        line(760 - y - 2, 760 - x + 2, 760 - y + 2, 760 - x + 2, RGB(255, 0, 0));
        line(760 - y + 2, 760 - x - 2, 760 - y + 2, 760 - x + 2, RGB(255, 0, 0));
        if (d < 0) {
            d += 2 * (x - 380) + 30;
        }
        else {
            d += 2 * ((x - 380) - (y - 380)) + 50;
            y -= 10;
        }
        x += 10;
        nanosleep((const struct timespec[]) { {0, 100000000L} }, NULL);  //每一次描点完成后延迟
    }
}

注：此代码编译环境为Qemu

  1. 圆的Bresenham画线算法
    原理：Bresenham与中点画线算法的不同在于前者可直接利用四对称画圆，而后者需要用到八对称，Bresenham算法将H,D,V三点到圆的的距离分别做减法。
    过程：构造函数：F(x,y)=x2 +y2 -r2
    Hi=(xi+1)2 +yi2 -r2
    Di=(xi+1)2 +(yi-1)2 -r2
    Vi=xi2 +(yi-1)2 -r2
    令d1=|Hi|-|Di|=2*(Di+yi)-1
    d2=|D|-|V|=2*(Di-xi)-1
    当Di<0时，若d1<0，取H点，反之取D点
    当Di>0时，若d2<0，取D点，反之取V点
    当Di=0时，取D点
    在这里插入图片描述
    确定取点后，需要确定下一像素点的递推公式如果取点为H点：D(i+1)=Di+2x(i+1)+1
    如果取点为D点：D(i+1)=Di+2    x(i+1)-2y(i+1)+2
    如果取点为V点：D(i+1)=Di-2*y(i+1)+1

核心代码如下：

//Bresenham画圆算法
void CircleDraw_Bresenham() {
    int x = 380, y = 380 + r;
    double x1 = x, y1, r1 = r;
    int delta=2*(1-r/10), delta1, delta2, direction;
    while ((x1 - 380) <= r1) {
        y1 = sqrt(r1 * r1 - (x1 - 380) * (x1 - 380));
        line(x1, 380 + y1, x1, 380 + y1, RGB(255, 0, 0));
        line(x1, 380 - y1, x1, 380 - y1, RGB(255, 0, 0));
        x1 += 0.01;
    }
    while ((-x1 + 380) <= r1) {
        y1 = sqrt(r1 * r1 - (x1 - 380) * (x1 - 380));
        line(x1, 380 + y1, x1, 380 + y1, RGB(255, 0, 0));
        line(x1, 380 - y1, x1, 380 - y1, RGB(255, 0, 0));
        x1 -= 0.01;
    }
    while (y >= 380) {
        line(x - 2, y - 2, x + 2, y - 2, RGB(0, 255, 0));
        line(x - 2, y - 2, x - 2, y + 2, RGB(0, 255, 0));
        line(x - 2, y + 2, x + 2, y + 2, RGB(0, 255, 0));
        line(x + 2, y - 2, x + 2, y + 2, RGB(0, 255, 0));
        line(x - 2, 760 - y - 2, x + 2, 760 - y - 2, RGB(0, 255, 0));
        line(x - 2, 760 - y - 2, x - 2, 760 - y + 2, RGB(0, 255, 0));
        line(x - 2, 760 - y + 2, x + 2, 760 - y + 2, RGB(0, 255, 0));
        line(x + 2, 760 - y - 2, x + 2, 760 - y + 2, RGB(0, 255, 0));
        line(760 - x - 2, y - 2, 760 - x + 2, y - 2, RGB(0, 255, 0));
        line(760 - x - 2, y - 2, 760 - x - 2, y + 2, RGB(0, 255, 0));
        line(760 - x - 2, y + 2, 760 - x + 2, y + 2, RGB(0, 255, 0));
        line(760 - x + 2, y - 2, 760 - x + 2, y + 2, RGB(0, 255, 0));
        line(760 - x - 2, 760 - y - 2, 760 - x + 2, 760 - y - 2, RGB(0, 255, 0));
        line(760 - x - 2, 760 - y - 2, 760 - x - 2, 760 - y + 2, RGB(0, 255, 0));
        line(760 - x - 2, 760 - y + 2, 760 - x + 2, 760 - y + 2, RGB(0, 255, 0));
        line(760 - x + 2, 760 - y - 2, 760 - x + 2, 760 - y + 2, RGB(0, 255, 0));
        if (delta < 0) {
            delta1 = 2 * (delta + (y-380) / 10) - 1; //HD距离大小
            if (delta1 <= 0)
                direction = 1;
            else direction = 2;
        }
        else if (delta > 0) {
            delta2 = 2 * (delta - (x-380) / 10) - 1; //DV距离大小
            if (delta2 < 0)
                direction = 2;
            else direction = 3;
        }
        else
            direction = 2;
        switch (direction) {
        case 1:                               //取H点
            x += 10;
            delta += 2 * ((x-380) / 10) + 1;
            break;
        case 2:                              //取D点
            x += 10;
            y -= 10;
            delta += 2 * ((x-380) / 10 - (y-380) / 10 + 1);
            break;
        case 3:                              //取V点
            y -= 10;
            delta += (-2) * ((y-380) / 10) + 1;
            break;
        }
        nanosleep((const struct timespec[]) { {0, 100000000L} }, NULL);
    }
}

注：此代码编译环境为Qemu

二、椭圆画线算法

  • 椭圆的Bresenham画线算法
    原理：由于椭圆的四对称性，考虑第一象限圆弧生成即可，并以切线斜率为-1的点作为分界点。
    过程：构造函数：F(x,y)=b2x2 +a2y2 -a2b2=0
    先对椭圆的上部分进行分析，中点判别式d1=F(xp+1,yp-0.5)=b2(xp+1)2 +a2(yp-0.5)2 -a2b2
    当d1<0，中点在椭圆内，取正右方的像素点，新判别式d1’=d1+b2(2xp+3)
    当d1>=0，中点在椭圆外，取右下方像素点，新判别式为d1’=b2(2xp+3)+a2(-2yp+2)
    d1的初始值为：b2 +a2(-b+0.25)
    在这里插入图片描述
    接着分析椭圆的下半部分，上半部分到下半部分的判断条件为b2x=-a2y
    当b2(xi+1)<a2(yi-0.5)时，处于椭圆的上半部分
    当b2(xi+1)>a2(yi-0.5)，椭圆由上半部分进入下半部分
    下半部分的判别式d2=F(xp+0.5,yp-1)=b2(xp+0.5)2 +a2(yp-1)2 -a2b2
    如果d2>0，取(xp,yp-1)，新判别式d2’=d2+a2(-2yp+3)
    如果d2<=0，取(xp+1,yp-1)，新判别式d2’=d2+b2(2xp+2)+a2(-2yp+3)
    d2的初始值为b2(x+0.5)2 +a2(y-1)2 -a2b2
    在这里插入图片描述

核心代码如下：

    //椭圆画线算法
void EllipseDraw() {
    int x = 500, y = 380 + b;
    int a1 = a / 10, b1 = b / 10;
    double d = b1 * b1 + a1 * a1 * (-b1 + 0.25);
    double x1 = x;
    double y1;
    while ((x1 - 500) <= a) {
        y1 = sqrt(b * b * (1 - ((x1 - 500) * (x1 - 500) / (a * a))));
        line(x1, 380 + y1, x1, 380 + y1, RGB(0, 255, 0));
        line(x1, 380 - y1, x1, 380 - y1, RGB(0, 255, 0));
        x1 += 0.1;
    }
    while ((-x1 + 500) <= a) {
        y1 = sqrt(b * b * (1 - (x1 - 500) * (x1 - 500) / (a * a)));
        line(x1, 380 + y1, x1, 380 + y1, RGB(0, 255, 0));
        line(x1, 380 - y1, x1, 380 - y1, RGB(0, 255, 0));
        x1 -= 0.1;
    }
    while (y>=380) {
        if (b1 * b1 * ((x - 500) / 10 + 1) < a1 * a1 * ((y - 380) / 10 - 0.5)) {
            line(x - 2, y - 2, x + 2, y - 2, RGB(255, 0, 0));
            line(x - 2, y - 2, x - 2, y + 2, RGB(255, 0, 0));
            line(x - 2, y + 2, x + 2, y + 2, RGB(255, 0, 0));
            line(x + 2, y - 2, x + 2, y + 2, RGB(255, 0, 0));
            line(1000 - x - 2, y - 2, 1000 - x + 2, y - 2, RGB(255, 0, 0));
            line(1000 - x - 2, y - 2, 1000 - x - 2, y + 2, RGB(255, 0, 0));
            line(1000 - x - 2, y + 2, 1000 - x + 2, y + 2, RGB(255, 0, 0));
            line(1000 - x + 2, y - 2, 1000 - x + 2, y + 2, RGB(255, 0, 0));
            line(x - 2, 760 - y - 2, x + 2, 760 - y - 2, RGB(255, 0, 0));
            line(x - 2, 760 - y - 2, x - 2, 760 - y + 2, RGB(255, 0, 0));
            line(x - 2, 760 - y + 2, x + 2, 760 - y + 2, RGB(255, 0, 0));
            line(x + 2, 760 - y - 2, x + 2, 760 - y + 2, RGB(255, 0, 0));
            line(1000 - x - 2, 760 - y - 2, 1000 - x + 2, 760 - y - 2, RGB(255, 0, 0));
            line(1000 - x - 2, 760 - y - 2, 1000 - x - 2, 760 - y + 2, RGB(255, 0, 0));
            line(1000 - x - 2, 760 - y + 2, 1000 - x + 2, 760 - y + 2, RGB(255, 0, 0));
            line(1000 - x + 2, 760 - y - 2, 1000 - x + 2, 760 - y + 2, RGB(255, 0, 0));
            if (d <= 0) {
                d += b1 * b1 * (2 * ((x - 500) / 10) + 3);
                x += 10;
            }
            else {
                d += b1 * b1 * (2 * ((x - 500) / 10) + 3) + a1 * a1 * ((-2) * ((y - 380) / 10) + 2);
                x += 10;
                y -= 10;
            }
            nanosleep((const struct timespec[]) { {0, 100000000L} }, NULL);
        }
        else {
            double d1 = b1 * b1 * ((x - 500) / 10 + 0.5) * ((x - 500) / 10 + 0.5) + a1 * a1 * ((y - 380) / 10 - 1) * ((y - 380) / 10 - 1) - a1 * a1 * b1 * b1;
            while (y >= 380) {
                line(x - 2, y - 2, x + 2, y - 2, RGB(255, 0, 0));
                line(x - 2, y - 2, x - 2, y + 2, RGB(255, 0, 0));
                line(x - 2, y + 2, x + 2, y + 2, RGB(255, 0, 0));
                line(x + 2, y - 2, x + 2, y + 2, RGB(255, 0, 0));
                line(x - 2, 760 - y - 2, x + 2, 760 - y - 2, RGB(255, 0, 0));
                line(x - 2, 760 - y - 2, x - 2, 760 - y + 2, RGB(255, 0, 0));
                line(x - 2, 760 - y + 2, x + 2, 760 - y + 2, RGB(255, 0, 0));
                line(x + 2, 760 - y - 2, x + 2, 760 - y + 2, RGB(255, 0, 0));
                line(1000 - x - 2, y - 2, 1000 - x + 2, y - 2, RGB(255, 0, 0));
                line(1000 - x - 2, y - 2, 1000 - x - 2, y + 2, RGB(255, 0, 0));
                line(1000 - x - 2, y + 2, 1000 - x + 2, y + 2, RGB(255, 0, 0));
                line(1000 - x + 2, y - 2, 1000 - x + 2, y + 2, RGB(255, 0, 0));
                line(1000 - x - 2, 760 - y - 2, 1000 - x + 2, 760 - y - 2, RGB(255, 0, 0));
                line(1000 - x - 2, 760 - y - 2, 1000 - x - 2, 760 - y + 2, RGB(255, 0, 0));
                line(1000 - x - 2, 760 - y + 2, 1000 - x + 2, 760 - y + 2, RGB(255, 0, 0));
                line(1000 - x + 2, 760 - y - 2, 1000 - x + 2, 760 - y + 2, RGB(255, 0, 0));
                if (d1 <= 0) {
                    d1 = d1 + b1 * b1 * (2 * (x - 500) / 10 + 2) + a1 * a1 * ((-2) * ((y - 380) / 10) + 3);
                    x += 10;
                    y -= 10;
                }
                else {
                    d1 = d1 + a1 * a1 * ((-2) * (y - 380) / 10 + 3);
                    y -= 10;
                }
                nanosleep((const struct timespec[]) { {0, 100000000L} }, NULL);
            }
        }
    }
}

注：此代码编译环境为Qemu

vmwarekali1
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
画圆椭圆算法（Bresenham、中点）.rar
10-20
实现了中点画圆和椭圆以及Bresenham画圆算法。考虑坐标不在中心原点的情况，椭圆可以横竖绘制不能倾斜，C++graphics.h图形库实现。
计算机图形学学习笔记（4.2）画圆与椭圆
大鹏的blog
03-07 2356
一般采用八分法画圆，由于圆的对称性，只需计算出八分之一圆弧的像素点即可。如下图： 最直接的想法是：利用简单函数方程，直接离散计算： 或者利用极坐标方程，直接离散计算，如下图： 联想到直线中点Bresenham画法（参考：Bresenham中点画线算法），同样地，我们可以通过圆的隐式方程来构造中点Bresenham画圆法。 中点Bresenham画圆法 同样地，我们只...
【计算机图形学】小白谈计算机图形学（二）画圆篇之中点画圆法,Bresenham画圆算法,椭圆实操，线型处理详解
一拳Marx
03-23 2908
小白谈计算机图形学（二）如何画圆引言如何画圆基本思想中点画圆法中点画圆基本思路中点画圆改进Bresenham画圆算法Bresenham基本思路数值微分改进中点画线法中点画线引言中点画线改进Bresenham画线法Bresenham基本思路Bresenham画线改进小结 引言 与直线不同，圆上每点的斜率都是变化的，这一讲我们来介绍圆的画法，首先注意到圆具有八对称性，即只需研究18\frac{1}{8...
直线绘制算法-中点画线法
SX2101111的博客
03-24 9323
之前讲过用数值积分法(DDA)进行直线逼近，通过向下取整获取目标像素点。计算过程中每一次都需要加0.5这一浮点数，浮点数运算效率相比整数运算效率低的多，因此需要对此进行改进。 一.中点画线法 直线方程式通过一般式表示：，调整A、B参数为整数。 点在直线上方则，点在直线直线下方则，点在直线上则 前提条件k∈[0,1]，且坐标已经确定。接下来需要判断下一个点是取点还是取点。判断的依据是看和的中点位于直线上方还是下方，若位于直线上方则取点，位于直线下方则取点，正好位于直线上则任取均可。
【计算机图形学】小白谈计算机图形学（一）画线篇之DDA算法,中点画线法,Bresenham画线法及相关改进详解
一拳Marx
03-22 7915
小白谈计算机图形学（一）如何划线引言如何画线基本思想数值微分法（DDA算法）数值微分基本思路数值微分改进中点画线法中点画线引言中点画线改进Bresenham画线法Bresenham基本思路Bresenham画线改进小结 引言 大家好，众所周知，计算机的图像显示是由一个一个像素组成，正如分子组成了世界，当像素合理分布，同样可以还原很多真实世界的场景。 如何画线 基本思想 已知过端点p0(x0,y0)...
作业_计算机图形学代码_
10-02
计算机图形学是一门涵盖广泛的学科，它涉及到计算机如何创建、处理和显示图像。在这个特定的“作业_计算机图形学代码_”中，我们关注的是一个使用easyx库实现的一笔绘制金刚石图案的项目。EasyX是一个轻量级的C++...
计算机图形学源码MFC实现
02-11
计算机图形学是一门深入研究如何在计算机中表示和处理图形的学科，它广泛应用于游戏开发、虚拟现实、图像处理、科学可视化等领域。本资源“计算机图形学源码MFC实现”是基于C++编程语言，利用Microsoft Foundation ...
计算机图形学（三）——实验三：圆的生成算法
chengzilhc的博客
06-13 8077
实验三：圆的生成算法 3.1实验目的 （1）了解DDA算法、中点画圆法、Bresenham算法 （2）掌握VC++中CDC类的用法 3.2实验内容 （1）类的编写 （2）完成DDA算法、中点画圆法、Bresenham算法 3.3算法思路 在平面解析几何中，圆的方程可以描述为(x–x0)2+(y–y0)2=R2，其中(x0,y0)是圆心坐标，R是圆的半径，特别的，当(x0,y0)就是坐标中心点时，圆方程可以简化为x2+y2=R2。在计算机图形学中，圆和直线一样，也存在点阵输出设备上显示或输出的问题，因此也需要
中点画线法讲解
weixin_44931542的博客
03-26 4796
中点画线法 基本算法： 当前象素点为(xp, yp)下一个象素点为P1 或P2设M=(xp+1, yp+0.5)，为p1与p2 之中点，Q为理想直线与x=xp+1垂线的交点。将Q与M的y坐标进行比较。 当M在Q的下方，则P2 应为下一个象素点； M在Q的上方，应取P1为下一点 构造判别式:d=F(M)=F(xp+1,yp+0.5)=a(xp+1)+b(yp+0.5)+c其中a=y0-y1, b...
计算机图形学 DDA画线算法及中点画线算法 学习笔记
qqQQqsadfj的博客
06-10 1350
慕课--------计算机图形学------中国农业大学
计算机图形学——八分法中点画圆
wangcl1999的博客
03-27 6423
八分法中点画圆 实现方法：从0°到45°开始画，其余部分进行求对称 1 、绘制X^2+Y^2=R^2的⚪，将⚪划分为八份。我们从第二份开始绘制分析 分析： 最大位移方向是Y方向，因此令y每增加1，x不变或者减少1，我们可以令： 2 、构造判别式 分析： 将M(xi-0.5,yi+1)点代入圆的稳式方程F(x,y)=X^2+Y^2-R^2 所以d=F(M)=(xi-0.5)^...
中点画圆算法
游戏开发、游戏引擎开发、逆向破解爱好者
04-21 4717
在平面解析几何中，圆的方程可以描述为(x – x0)2+ (y – y0)2= R2，其中(x0, y0)是圆心坐标，R是圆的半径，特别的，当(x0, y0)就是坐标中心点时，圆方程可以简化为x2+ y2= R2。在计算机图形学中，圆和直线一样，也存在在点阵输出设备上显示或输出的问题，因此也需要一套光栅扫描转换算法。为了简化，我们先考虑圆心在原点的圆的生成，对于中心不是原点的圆，可以通过坐...
算法系列之十一：圆生成算法
java开发指南博客 【转载】
02-12 2136
&lt;!-- Search Google --&gt; 输入您的搜索字词 提交搜索表单 &lt;!-- Search Google --&gt; 在平面解析几何中，圆的方程可以描述为(x – x0)2 + (y – y0)2 = R2，其中(x0, y0)是圆心坐标，R是圆的半径，特别的，当(x0, y0)就是坐标中心点时，圆方程可以简化为x2 + y2 = R2。在计算机图形学中，圆...
Bresenham直线算法与画圆算法
weixin_33875564的博客
04-02 1412
在我们内部开发使用的一个工具中，我们需要几乎从 0 开始实现一个高效的二维图像渲染引擎。比较幸运的是，我们只需要画直线、圆以及矩形，其中比较复杂的是画直线和圆。画直线和圆已经有非常多的成熟的算法了，我们用的是Bresenham的算法。 计算机是如何画直线的？简单来说，如下图所示，真实的直线是连续的，但我们的计算机显示的精度有限，不可能真正显示连续的直线，于是我们用一系列离散化后的点（像素）来近似...
中点画线算法画直线----计算机图形学
但行好事，莫问前程
10-09 8028
中点画线算法： 所需绘制直线的左下端点记为，右上端点记为 令 ,,则直线的斜截式为 ： 所以，用隐函数表示直线的方程为 ： 容易验证，点（x , y）若在直线上，F（x , y）= 0 ；若在直线上方，F（x , y）>0 ；若在直线下方，F（x , y）<0 。 （1）. 斜率在 （0,1）区间： ...
bresenham画直线，画圆算法（转）
qq_41437694的博客
03-08 887
Bresenham算法画直线： 我们在电脑上看到的图像时由一个个像素点拼接而成，当你放大图像就可以观察到这点。以下是一条直线： 它是由这些像素点一个一个拼接而成，那么问题来了，怎样选取这些点，使我们看到的更像是一条直线呢？ 我们的主要思路就是，谁靠近直线我们就选谁，近水楼台先得月。如下图，因为,所以我们选择直线下面的黄点作为画直线的点。 依照这个原则，直到终点。这样一条线就出来了。所以我们得比较...
计算机图形学实验-画直线画圆
最新发布
m0_52562878的博客
05-05 1104
利用DDA算法、中点画线算法、Bresenham算法画直线 利用中点圆画法及Bresenham两种画法画圆
计算机图形学（二）输出图元_6_OpenGL曲线函数_3_椭圆生成算法
heyuchang666的专栏
04-22 2781
通过椭圆上任一点到称为椭圆焦点的两个定点的距离可给出椭圆的精确定义:椭圆上任一点到这两点的距离之和都等于一个常数(参见图3.21 )。如果椭圆上的任一点P = (x,y)到两个焦点的距离为d1和d2，那么椭圆的通用方程可以表示为
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值