• 计算机图形学 opengl版本 第三版------胡事民 第三章更多的绘图工具


    opengl  计算机图形学 第三版   第二部分   第三章更多的绘图工具

    3.1   概述

    第2章中  我们绘图使用的是屏幕窗口的基础坐标系    以像素为单位  

    屏幕坐标从左下角x从0延伸到screenWidth-1         y从0向上延伸到screenHeight-1       只能使用非负的x和y

    程序中用于描述对象几何信息    此过程为建模任务

    在屏幕中如何将这个对象  按照一定比例显示出来    是一个观看的任务

      使用最适合与手中问题的坐标系来描述对象,并且可以自动的缩放和平移图片,使得其能正确地在屏幕窗口中显示,这个描述对象的空间被称为世界坐标系(场景中的物体在实际世界中的坐标)。在合适的单位下,它就是数学中常用的笛卡尔xy坐标系。

      世界窗口:在世界坐标系中定义一个对齐的矩形     (矩形的边与坐标轴平行)        不一定是屏幕

      世界窗口指明了要绘制世界的哪一部分。对此可以理解为,任何在窗口中的部分需要被绘制,而窗口外的部分被裁减并不被绘制。  opengl会自动的裁减。

      显示器的屏幕窗口上定义一个对齐的矩形的视口,不同于世界窗口     opengl会自动建立世界窗口和视口的变换(包括缩放和平移)。

       对象在世界窗口中显示的部分会被自动的映射到视口中,也就是被映射到屏幕坐标中。

    对齐的矩形作为窗口和视口(屏幕窗口)的形状原因:

      1.矩形仅需要四个参数描述

      2.检测一个点的位置(窗口内外) 很容易,可以简化裁减算法。

      3.对齐的矩形为凸   简化绘制算法

      4.通过一个窗口取看被绘制的物体,  并价格窗口中可见的快照放到显示器的视口中

      采用窗口/视口的联合方式,  当两个口被指定时,coder可以编写一个算法,不考虑图片的大小和位置,所有潜在的操作(缩放、位置和裁减)都会自动完成,并将图片放到视口中去。

    3.2世界窗口和视口

      创建一个函数图像之后,并不知道 图像的位置和图像的大小,所以使用世界窗口就非常的重要

      setWindow()用来建立世界窗口

      setViewport()来建立视口

      代码中涉及的坐标是在自然坐标系中操作的   例如x在-4.0~4.0    变化的   关键问题是如何缩放和平移不同的(x,y)   使得图像能在屏幕窗口中恰当的显示。

      通过设置一个世界窗口和一个视口,并建立它们之间的一个合适的映射,就可以完成适当的平移和缩放。视口和窗口是coder 指定的对齐的矩形。

      窗口为世界坐标系中

      视口为屏幕窗口的一部分。

      

      前者为世界窗口;后者为在屏幕中划出一部分区域为屏幕窗口,在其中再画出一部分为视口。

    3.2.1  窗口到视口的映射

      

      图中的w和v都是GLfloat类型的数值,代表作标值,其中left  和right为x轴的值   、 bottom和top为y轴的值,综合到一起成为了对齐的矩形

      世界窗口和视口  纵横比不一定一致    如果不一致会导致图像的拉伸,所以需要调整世界窗口和视口的纵横比一致

      一个映射或者变换,即窗口到视口的映射,这个映射是基于一个等式,对每一个在世界坐标下的点(x,y),产生屏幕坐标系中的一个点(sx,sy)。

      保持比例的性质  有下面的线性性质:

          sx=A*x+C

          sy=B*y+D

      其中A、B、C、D是常数,       A B缩放x和y的坐标    而 C D用来平移它们。

      

      

    a  如果x是窗口的左边界    x=w.left         则sx为视口的左边界     sx=v.left

    b  如果x是在窗口的右边界x=w.right,则sx是在视口的右边界    sx=v.right

    c  对于某个比例f    如果x位于窗口的1/f处      则sx位于视口宽度的1/f处

    d  如果x在窗口的左边界外    x<w.left      则sx也在视口的的左边界外     sx<v.left

     设立窗口到视口的映射

      opengl通过多个变换完成所需要的映射,自动的传送给定的每一个顶点   通过glVertex2*()命令

      二维图形中,世界窗口由函数gluOrth2D()来设定    原型如下:

        void gluOrtho2D(GLdouble left,GLdouble right,GLdouble bottom,GLdouble top);     

      三维的情况  还有另外两个参数需要设定    省略

      视口的设定:

        void glViewport(GLint x,GLint y,GLint width,GLint eight);          左下角的坐标以及宽度和高度

      通过矩阵来完成所有的变换,因此gluOrtho2D()的调用必须在glMatrixModel(GL_PROJECTION)和glLoadIdentity()两个函数之后完成

      所以建立窗口设视口之间的联系需要如下代码:

      glMatrixModel(GL_PROJECTION;

      glLoadIdentity();

      gluOrtho2D(0.0,2.0,0.0,1.0);  设置窗口

      glViewport(40,60,360,240);   设置视口

      在此之后  每个使用glVertex2*(x,y)发送给opengl的点,会进行等式的映射,并且在窗口的边界处会被自动裁减掉边缘。

      将设定窗口的函数放在setWindow()函数中     将glViewport()   放在setViewport函数中

      void setWindow(GLdouble left,GLdouble right,GLdouble bottom,GLdouble top)      设置窗口

      {

        glMatrixModel(GL_PROJECTION);

        glLoadIdentity();

        gluOrtho2D(left,right,bottom,top);

      }

       void setViewport(GLint left,GLint right,GLint bottom,GLint top)              设置视口

      {

        glViewport(left,bottom,right-left,top-bottom);

      }

     (1)在main()中

      glutInitWindowSize(640,480)      设置窗口大小

      没有使用glViewport的命令   所以使用默认的视口,默认的视口就是整个屏幕窗口。

    (2)在myInit()中

      glMatrixModel(GL_PROJECTION);

      glLoadIdentity();

      gluOrtho2D(0.0,640.0,0.0,480.0);      //关键的设置   与视口比较      以及纵横比

      上面这些函数都是将世界窗口设置为对齐的矩形,其两个角的坐标是(0,0)和(640.0,480.0)  正好与视口的大小相等。

      案例1:针对同一个图案,使用不同的视口,可以做到在屏幕窗口上的平铺

       

       例如a所示的就是平铺

      代码如下:      将恐龙替换成矩形     代码如下

    setWindow(0,640.0,0,440.0)        //设置窗口
    for(int i=0,i<5;i++)                     //每列
    {
       for(int j=0;j<5;j++)                 //每行
        {
            glViewport(i*64,j*44,64,44)   //  视口的移动方向先第0列  再第1列 ...
            drawPolylineFile("dino.dat");//在绘制一遍
        }  
    }                    
    其中dino.dat为折线的文件

    //折线恐龙
    #include <windows.h>
    #include <gl/gl.h>
    #include <gl/glu.h>
    #include <gl/glut.h>
    #include <iostream>
    #include <math.h>
    using namespace std;
    const int screenWidth=250;
    const int screenHeight=250;
    void setWindow(GLdouble left,GLdouble right,GLdouble bottom,GLdouble top)        //设置窗口
    {
        gluOrtho2D(left,right,bottom,top);//窗口到视口的转换
    }
    void setViewport(GLint left,GLint right,GLint bottom,GLint top)      //设置视口
    {
        glViewport(left,bottom,right-left,top-bottom);
    }
    void myInit(void)
    {
        glClearColor(1.0,1.0,1.0,0.0);              //背景颜色  白色    最亮
        glColor3f(0.0f,0.0f,0.0f);                  //线条颜色为黑色
        glPointSize(10.0);                           //点像素大小
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        setWindow(0,60.0,0,60.0);//设置世界坐标系中的窗口
    }
    void draw(void)             //画图函数
    {
        glBegin(GL_LINE_LOOP);   //三角形的点
                    glVertex2i(10,10);
                    glVertex2i(10,50);
                    glVertex2i(50,50);
        glEnd();
    }
    void myDisplay(void)    //注册函数
    {
       glClear(GL_COLOR_BUFFER_BIT);
       for(int i=0;i<5;i++)
       {
          for(int j=0;j<5;j++)
          {
           glViewport(i*50,j*50,50,50);         //设置视口
           draw();
          }
       }
        glFlush();
    }
    int main(int argc,char ** argv)
    {
        glutInit(&argc,argv);
        glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
        glutInitWindowSize(screenWidth,screenHeight);
        glutInitWindowPosition(100,150);
        glutCreateWindow("折线矩形");
        glutDisplayFunc(myDisplay);
        myInit();
        glutMainLoop();
        return 0;
    }

    下图为执行效果图:

    b图为交替倒置  产生的效果

      判断i+j是偶数和奇数,然后倒转top和bottom的值   以实现视口的倒转

      代码如下:  

    for(int i=0;i<5;i++)//
    {
        for(int j=0;j<5;j++)//
        {
          if((i+j)%2==0)//i+j是偶数
            setWindow(0.0,640.0,0.0,440.0);//正常的世界窗口
          else //i+j为奇数
            setWindow(0.0,640.0,440.0,0.0);//颠倒的世界窗口
          glViewport(i*64,j*44,64,44);//设置下一个视口
          drawPloylineFile("dino.dat");//再次绘制  
        }
    }

    完整代码如下

    //折线恐龙
    #include <windows.h>
    #include <gl/gl.h>
    #include <gl/glu.h>
    #include <gl/glut.h>
    #include <iostream>
    #include <math.h>
    
    using namespace std;
    
    const int screenWidth=250;
    const int screenHeight=250;
    
    void setWindow(GLdouble left,GLdouble right,GLdouble bottom,GLdouble top)        //设置窗口
    {
        glMatrixMode(GL_PROJECTION);                //以下这两句一定要从myInit函数中抽出放到此位置
        glLoadIdentity();
        gluOrtho2D(left,right,bottom,top);          //窗口到视口的转换
    }
    void setViewport(GLint left,GLint right,GLint bottom,GLint top)      //设置视口
    {
        glViewport(left,bottom,right-left,top-bottom);
    }
    
    void myInit(void)
    {
        glClearColor(1.0,1.0,1.0,0.0);              //背景颜色  白色    最亮
        glColor3f(0.0f,0.0f,0.0f);                  //线条颜色为黑色
        glPointSize(10.0);                          //点像素大小
    }
    void draw(void)                                 //画图函数
    {
        glBegin(GL_LINE_LOOP);
                    glVertex2i(10,10);
                    glVertex2i(10,50);
                    glVertex2i(50,50);
    
        glEnd();
    }
    void myDisplay(void)    //注册函数
    {
       glClear(GL_COLOR_BUFFER_BIT);
       for(int i=0;i<5;i++)
       {
          for(int j=0;j<5;j++)
          {
            if((i+j)%2==0)//i+j是偶数
            setWindow(0.0,60.0,0.0,60.0);//正常的世界窗口
            else //i+j为奇数
            setWindow(0.0,60.0,60.0,0.0);//颠倒的世界窗口
            glViewport(i*50,j*50,50,50); //设置视口
            draw();
          }
       }
        glFlush();
    }
    int main(int argc,char ** argv)
    {
        glutInit(&argc,argv);
        glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
        glutInitWindowSize(screenWidth,screenHeight);
        glutInitWindowPosition(100,150);
        glutCreateWindow("折线矩形");
        glutDisplayFunc(myDisplay);
        myInit();
        glutMainLoop();
        return 0;
    }

    执行结果的图片

    裁减图片的某部分

    视口不变,改变世界窗口 用以显示不同的图案

    上例中w1   和w2两个不同的窗口       视口不变,当使用w1时屏幕视口中显示的是w1中所裁切出的图案,而使用w2时则屏幕显示的是w2中裁切出的图案。

    代码框架如下: 

    setWindow(...);       //每张图片都改变窗口
    setViewport(...);     //每张图片使用同样的视口
    hexSwirl();             //调用同样的画图函数

    坐标系统绘制

    //画笛卡尔坐标系
    
    #include <windows.h>
    #include <gl/gl.h>
    #include <gl/glu.h>
    #include <gl/glut.h>
    #include <iostream>
    #include <math.h>
    
    using namespace std;
    
    const int screenWidth=1024;
    const int screenHeight=768;
    
    void setWindow(GLdouble left,GLdouble right,GLdouble bottom,GLdouble top)
    {
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluOrtho2D(left,right,bottom,top);
    }
    
    void setViewport(GLint left,GLint right,GLint bottom,GLint top)
    {
        glViewport(left,bottom,right-left,top-bottom);
    }
    
    void drawpolygon(void)
    {
        setWindow(0,screenWidth,0,screenHeight);
        setViewport(0,screenWidth,0,screenHeight);
        glClear(GL_COLOR_BUFFER_BIT);
        glBegin(GL_POINTS);
            for(int x=0;x<=screenWidth;x++)
            glVertex2i(x,screenHeight/2);
            for(int y=0;y<=screenHeight;y++)
            glVertex2i(screenWidth/2,y);
        glEnd();
        glFlush();
    }
    void myInit(void)
    {
        glClearColor(1.0,1.0,1.0,0.0);
        glColor3f(0.0f,0.0f,0.0f);
        glPointSize(3.0);
    }
    
    int main(int argc,char ** argv)
    {
        glutInit(&argc,argv);
        glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
        glutInitWindowSize(screenWidth,screenHeight);
        glutInitWindowPosition(100,150);
        glutCreateWindow("画坐标系");
        glutDisplayFunc(drawpolygon);
        myInit();
        glutMainLoop();
        return 0;
    }

     画六边形:

    //画笛卡尔坐标系中的六边形
    #include <windows.h>
    #include <gl/gl.h>
    #include <gl/glu.h>
    #include <gl/glut.h>
    #include <iostream>
    #include <math.h>
    using namespace std;
    
    typedef struct point{
    GLdouble x;
    GLdouble y;
    }point;
    
    const int screenWidth=500;
    const int screenHeight=500;
    const int N=6;
    point sp[N];
    point temp;     //全局变量
    double pi=3.1415926;
    double theta=2*pi/N;
    double r=150;
    
    void moveto(GLdouble x,GLdouble y)  //设置当前的笔触到坐标点
    {
        temp.x=x;
        temp.y=y;
    }
    
    void lineto(GLdouble x,GLdouble y)//从当前的点画线到指定的坐标点  两点间的连线
    {
        glBegin(GL_LINES);
            glVertex2d(temp.x,temp.y);
            glVertex2d(x,y);
        glEnd();
        //glFlush();
        temp.x=x;   //重新设置当前虚拟笔触的坐标值
        temp.y=y;
    }
    
    void setWindow(GLdouble left,GLdouble right,GLdouble bottom,GLdouble top)   //设置窗口
    {
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluOrtho2D(left,right,bottom,top);
    }
    void setViewport(GLint left,GLint right,GLint bottom,GLint top) //设置视口
    {
        glViewport(left,bottom,right-left,top-bottom);
    }
    int drawpolygon(struct point  p[],GLdouble theta,GLdouble r)//注意传递的参数   接收的参数
    {
        setWindow(0,screenWidth,0,screenHeight);
        setViewport(0,screenWidth,0,screenHeight);
        glClear(GL_COLOR_BUFFER_BIT);
        glBegin(GL_POINTS);
            for(int x=0;x<=screenWidth;x++)       //画坐标系
            glVertex2i(x,screenHeight/2);
            for(int y=0;y<=screenHeight;y++)
            glVertex2i(screenWidth/2,y);
            for(int i=0;i<N;i++)
            {
                double x=r*cos(i*theta)+screenWidth/2;  //计算六个点的坐标   并画出
                double y=r*sin(i*theta)+screenHeight/2;
                glVertex2i(x,y);
               p[i].x=x;
               p[i].y=y;
            }
        glEnd();
        for(int i=0;i<N;i++)                    //画线循环
        {
            moveto(sp[i].x,sp[i].y);    //利用全局变量   来画六边形
            lineto(sp[(i+1)%6].x,sp[(i+1)%6].y);//取模算余数
        }
        glFlush();
        return 0;
    }
    void mydisplay(void)                //注册的函数
    {
        //
        drawpolygon(sp,theta,r);
    
    }
    void myInit(void)
    {
        glClearColor(1.0,1.0,1.0,0.0);
        glColor3f(0.0f,0.0f,0.6f);
        glPointSize(6.0);
    }
    int main(int argc,char ** argv)
    {
        glutInit(&argc,argv);
        glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
        glutInitWindowSize(screenWidth,screenHeight);
        glutInitWindowPosition(100,150);
        glutCreateWindow("画六边形");
        glutDisplayFunc(mydisplay);
        myInit();
        glutMainLoop();
        return 0;
    }

     结果如下:

     多个六边形

    //多六边形
    #include <windows.h>
    #include <gl/gl.h>
    #include <gl/glu.h>
    #include <gl/glut.h>
    #include <iostream>
    #include <math.h>
    using namespace std;
    
    typedef struct point{
    GLdouble x;
    GLdouble y;
    }point;
    
    const int screenWidth=500;
    const int screenHeight=500;
    const int N=6;
    point sp[N];
    point temp;     //全局变量
    double pi=3.1415926;
    double theta=2*pi/N;
    double r=240;
    
    void moveto(GLdouble x,GLdouble y)  //设置当前的笔触到坐标点
    {
        temp.x=x;
        temp.y=y;
    }
    
    void lineto(GLdouble x,GLdouble y)//从当前的点画线到指定的坐标点  两点间的连线
    {
        glBegin(GL_LINES);
            glVertex2d(temp.x,temp.y);
            glVertex2d(x,y);
        glEnd();
        //glFlush();
        temp.x=x;   //重新设置当前虚拟笔触的坐标值
        temp.y=y;
    }
    
    void setWindow(GLdouble left,GLdouble right,GLdouble bottom,GLdouble top)   //设置窗口
    {
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluOrtho2D(left,right,bottom,top);
    }
    void setViewport(GLint left,GLint right,GLint bottom,GLint top) //设置视口
    {
        glViewport(left,bottom,right-left,top-bottom);
    }
    int drawpolygon(struct point  p[],GLdouble tempt,GLdouble tempr)//注意传递的参数   接收的参数
    {
        //setWindow(0,screenWidth,0,screenHeight);
        //setViewport(0,200,0,200);
    
        glBegin(GL_POINTS);
            //for(int x=0;x<=screenWidth;x++)       //画坐标系
            //glVertex2i(x,screenHeight/2);
            //for(int y=0;y<=screenHeight;y++)
            //glVertex2i(screenWidth/2,y);
            for(int i=0;i<N;i++)
            {
                double x=tempr*cos(i*tempt)+screenWidth/2;  //计算六个点的坐标   并画出
                double y=tempr*sin(i*tempt)+screenHeight/2;
                glVertex2i(x,y);
                p[i].x=x;
                p[i].y=y;
            }
        glEnd();
       for(int i=0;i<N;i++)                    //画线循环
        {
            moveto(sp[i].x,sp[i].y);    //利用全局变量   来画六边形
            lineto(sp[(i+1)%6].x,sp[(i+1)%6].y);//取模算余数
        }
       // for(int j=0;j<N;j++)
    
        return 0;
    }
    void mydisplay(void)                //注册的函数
    {
        glClear(GL_COLOR_BUFFER_BIT);
        setWindow(0,screenWidth,0,screenHeight);
        setViewport(0,screenWidth,0,screenHeight);
        while(r>0)                   //循环画六边形
            drawpolygon(sp,theta,r-=10);
        glFlush();
        cout<<sp[1].x<<endl;
    }
    void myInit(void)
    {
        glClearColor(1.0,1.0,1.0,0.0);
        glColor3f(0.0f,0.0f,0.6f);
        glPointSize(3.0);
    }
    int main(int argc,char ** argv)
    {
        glutInit(&argc,argv);
        glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
        glutInitWindowSize(screenWidth,screenHeight);
        glutInitWindowPosition(100,150);
        glutCreateWindow("画六边形");
        glutDisplayFunc(mydisplay);
        myInit();
        glutMainLoop();
        return 0;
    }

    结果:

    缩放和漫游

        将窗口变小则用于放大对象    相反窗口变大  相当于对象缩小。

        有时候漫游也叫全视

    在动画中放大图片

          同心的多个窗口   固定的纵横比    窗口逐渐缩小   形成动画,每个窗口中显示的图片都是一帧     此过程类似与放大图像

        绘制每一帧   都需要清一次屏幕   同时窗口越来越小  代码如下:      

    动画1:

    float cx=0.3,cy=0.2;//窗口中心
    float H,W=1.2, aspect=0.7;//窗口性质
    set the viewport    //设置视口
    for(int frame=0;frame<NumFrames;frame++)//循环显示每一帧图像
    {
        clear the screen       //每次循环都清除之前的图案
        W*=0.7;
        H=W*aspect;          //保持纵横比
        setWindow(cx-W,cx+W,cy-H,cy+H);//设置下一个窗口
        hexSwirl();
    }

    动画2:

       动画1的方式存在的问题

       过程如下:

        迅速擦除当前的图像;然后新图像被缓慢的重绘,因为仅仅有一个图像的缓存

       解决上面问题的方法就是在用户浏览当前图像时,在一个“屏幕外内存”的地方绘制新的图像,然后将新图像显示在显示器上。

         opengl提供了双缓存来完成任务,使用一个内存来模拟一个额外的屏幕,这个屏幕不显示在真实的显示器上,并所有的绘制都在这个缓存中进行。之后glutSwapBuufers()函数会将缓存中的图片转移到屏幕窗口上。

        设置单缓存:glutInitDisplayModel(GLUT_SINGLE | GLUT_RGB);   

       设置成双缓存:glutInitDisplayModel(GLUT_DOUBLE | GLUT_RGB); 

    练习:3.2.2回旋的旋涡

          

      

    3.3 裁减线

      图形学中的基本任务,用于保持对象在给定的区域外的部分不被绘制

      opengl环境中,每个对象都会被一个特殊的算法,自动的裁减到世界窗口      裁减器

    3.3.1裁减一条线

      cohen-sutherland 裁减器  计算p1和p2两个端点的线段的哪一部分位于世界窗口之内,并返回位于世界窗口内的部分的端点

      函数 int clipSegment(Point2& p1,Point2& p2,RealRect window)    参数为两个二维的点以及一个对齐的矩形    

      功能为将p1和p2为端点的线段裁减到窗口边界处。如果线段的某一部分位于窗口内,则将新的端点存放在p1 和p2中,并且函数返回1,说明线段的某些部分是可见的。如果这条线温泉被裁减掉了,函数返回0,说明没有任何部分可见。

            案例1:

      

      典型的裁减器的情况    :   clipsegment()函数对每条线段执行下列事件中的一件。

      1.如果整条线段都在窗口内(例如线段cd)    函数返回1    

      2.整条线段在窗口外    例如线段AB  函数返回0

      3.一个端点在窗口外,一个在窗口内    例如ED      函数将一个端点裁减   设置新的端点    然后返回1

      4.两个端点都在窗口外,     但是此线段的一部分位于窗口内   例如线段AE    函数将裁减两个端点   并返回1

      还有可能线段位于窗口的左侧   右侧    上面或者下面等等。

      为了判断线段的位置  并且做出相应的裁减    cohen-sutherland提供了一个快速的分治算法。

      3.3.2  cohen-sutherland裁减算法

      平凡接受和平凡拒绝两种常见情况

      

      图中的AB整个线段位于窗口内     因此AB被平凡的接受,而不需要裁减,                    窗口很大时,大部分情况都是平凡接受。

      图中CD整个线段   两个端点都位于W的另一条边外,则线段CD整个都在窗口外  此时CD就是平凡的拒绝。       窗口很小时,大部分情况都是平凡拒绝。

    检测平凡接受或者平凡拒绝

      仅仅检测端点即可

      

      对线段的每一个端点计算一个“窗口内部/外部编码”,用于后续的测试。

        四个编码的位置信息从左到右分别为    left     above     right     below       分别代表   在左面    上面    下面   右面;

      t代表true       f代表false

      如果点在窗口内部,则编码表示为FFFF;

      下图为点与窗口的位置关系   的9种可能性

      

      平凡接受:两个码字都是FFFF;

      平凡拒绝:两个码字在某一位元素上都是T   两个点都是在窗口左边,或者都在它上面,等等

      使用c/c++的位操作函数   可以实现码字的计算和测试。

    没有平凡接受和拒绝时的截断

      

      如果没有平凡接受或者拒绝时,此线段一定会被某个边界分成两个部分

      do

      {

        设置p1   和p2的码字;

        if(平凡接受)  return 1;

        if(平凡拒绝)  return 0;

        将线段在下一个窗口边界处截断;(重新设置p1或p2端点的位置)丢掉外面的部分;

      }while(1);

      最多四次循环就会终止,针对每个点  对齐矩形的四条边都会进行检测   所以需要四次循环。也就会出现平凡接受或者平凡拒绝的情况。

      

       已知:p1和p2的坐标x和y       w.right     

       未知:A点的x=w.right     y=p1.y-d

        d/dely=e/delx

        delx=p2.x-p1.x;.........1

        dely=p2.y-p1.y;........2

        e=p1.x-w.right;.........3

       由1 2 3可以计算出d的值   由此就可以计算出A点的y值

      所以新p1.y  (点A)   

        p1.y+=(w.right-p1.x)*dely/delx

      剩余的窗口的三个边界的裁减方法类似。

      对于水平的线  dely=0 ;对于垂直的线   delx=0;    分母为0的情况不会发生

      伪代码2:

      

    int clipSegment(Point & p1,Point2& p2,RealRect W)
    {
        
        do{
           if(平凡接受) return 1;
           if(平凡拒绝) return 0;
           if(p1在窗口外面)
           {
                if(p1在窗口左边)   用左边界截断,更新p1;
                else if(p1在窗口右边) 用右边界截断,更新p1;
                else if(p1在窗口下面) 用下边界截断,更新p1;
                else if(p1在窗口上面) 用上边界截断,更新p1;
           }
            else //p2在窗口外面
            {
                if(p2在窗口左边)   用左边界截断,更新p2;
                else if(p2在窗口右边) 用右边界截断,更新p2;
                else if(p2在窗口下面) 用下边界截断,更新p2;
                else if(p2在窗口上面) 用上边界截断,更新p2;
            }
        }while(1);
    }
       

      每次执行循环时,每个端点的码字都会被重新计算和测试,每次都会对平凡接受和拒绝进行检测  ,如果失败,算法会检测p1是否在窗口外,如果p1在窗口内,那么p2一定在窗口外,针对在窗口外的点进行按边裁减。

      裁减的顺序为左,右,下,上。

      

      第一次:p1变为A

      第二次:p2变为B

      第三次:A变为C

      第四次:  B变为D

     练习:3.3.1  手工模拟clipSegment   (略)

     3.3.2 除以0的情况永远不会发生。

    3.4正多边形、圆和圆弧

    3.4.1正多边形

      所有边相等   内角相等  且边只能在端点处接触,称n条边的正多边形为正n边形。顶点等距离排放

      

      半径为R的外接圆的圆心位于远点,而第一个点p0位于x轴的正方向,其它的顶点位于下面等式指定的位置:pi=(R*cos(i*a),R*sin(i*a)),      i=1,2...5

      其中a=2π/6=π/3。

      1.如果圆心的坐标为(x,y),只要在上式中坐标中分别加上x和y即可。

      2.如果将正六边形缩放S倍,只需要将R乘上S。

      3.旋转只需要在cos和sin函数的参数中增加A即可

    3.4.2正n边形的变种

      将正n边形中的各个顶点均相连 会得到花环 

     花环.cpp

    //绘制sinc函数
    #include <windows.h>
    #include <iostream>
    #include <math.h>
    #include <gl/GL.h>
    #include <gl/GLU.h>
    #include <gl/GLUT.h>
    
    
    class GLintPoint        //点类
    {
    public:
        GLint x,y;
    };
    
    class Point2            //线段端点类
    {
    public:
        float x,y;
        void set(float dx,float dy){x=dx;y=dy;}     //内联函数     且重载
        void set(Point2 &p){x=p.x;y=p.y;}           //内联函数     重载    设置端点
        Point2(float xx,float yy){x=xx,y=yy;}       //构造函数   非默认
        Point2(){x=y=0;}                            //默认构造函数
    };
    Point2 currPos;                     //定义两个端点类的对象
    Point2 CP;
    
    void moveTo(Point2 p)              //移动当前的虚拟笔触   到一个端点
    {
        CP.set(p);                      //设置当前点的坐标
    }
    
    void lineTo(Point2 p)               //从当前点的位置cp     到参数给定的点划线
    {
        glBegin(GL_LINES);
            glVertex2f(CP.x,CP.y);
            glVertex2f(p.x,p.y);
        glEnd();
        glFlush();
        CP.set(p);                  //***重新设置当前的点  cp
    }
    //myInit
    void myInit(void)           //初始化  窗口的个参数    背景颜色    线条颜色  以及宽度等等
    {
        glClear(GL_COLOR_BUFFER_BIT);
        glClearColor(1.0,1.0,1.0,0.0);
        glColor3f(0.0f,0.0f,1.0f);
    }
    
    void rosette(int N,float radius)        //触发的画图函数    参数为点数 和 半径值
    {
        Point2 * pointlist=new Point2[N];       //创建数组用来存储线段的端点
        GLfloat theta=(2.0f*3.1415926536)/N;    //360度除以点数   算出角度数
        for(int c=0;c<N;c++)
        {
            pointlist[c].set(radius*sin(theta*c),radius*cos(theta*c));//计算每个点的x和y值   并且填入对象数组
        }
        for(int i=0;i<N;i++)//将数组中的所有点都连接起来
        {
            for(int j=0;j<N;j++)
            {
                moveTo(pointlist[i]);
                lineTo(pointlist[j]);
            }
    
        }
    }
    
    void render()//渲染
    {
        glClear(GL_COLOR_BUFFER_BIT);//清除背景颜色
        glViewport(10,10,600,600);      //设置视口 *****  x,y    width   height
        rosette(10,.50f);            //画图    实参传送
        glFlush();                  //传送给opengl
    }
    //main
    int main(int argc,char ** argv)
    {
        glutInit(&argc,argv);
        glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        glutInitWindowSize(600,600);
        glutCreateWindow("rosette");
        glutDisplayFunc(render);
        myInit();
        glutMainLoop();
        return 0;
    }

     特例:    5花环 的特性

      体现很多黄金分割率φ

      

       每条线段要比短于它的线段长φ倍,而且由于五角星的边又构成了一个内五边形,可以实现一个无穷的嵌套。

    例子:3.4.2基于两个同心多边形的图形

       

        外半径是R,内半径是fR ,f是某个因子。每个图都使用了一个正n边形的变种,其半径在内径和外径之间交替。

        图3.29a   代码示例:

      

    //3.2.9图a
    
    #include <windows.h>
    #include <gl/gl.h>
    #include <gl/glu.h>
    #include <gl/glut.h>
    #include <iostream>
    #include <math.h>
    
    using namespace std;
    
    const int N=6;
    const double pi=3.1415926;
    const double theta=2*pi/N;
    const double R=200;
    const double r=50;
    const double screenWidth=500;
    const double screenHeight=500;
    
    class point
    {
      public:
        GLdouble x;
        GLdouble y;
        void setp(GLdouble _x,GLdouble _y){x=_x;y=_y;};
    
    };
    point sp;
    void moveTo(GLdouble x,GLdouble y)
    {
       sp.setp(x,y);
    }
    void lineTo(GLdouble x,GLdouble y)
    {
        glBegin(GL_LINES);
            glVertex2d(sp.x,sp.y);
            glVertex2d(x,y);
        glEnd();
        sp.x=x;
        sp.y=y;
    }
    void photo(void)
    {
        class point p1[6];
        class point p2[6];
        glClear(GL_COLOR_BUFFER_BIT);
        glBegin(GL_POINTS);
        for(int i=0;i<N;i++)
        {
            GLdouble Rx=R*cos(i*theta)+screenWidth/2;
            GLdouble Ry=R*sin(i*theta)+screenHeight/2;
            p1[i].x=Rx;
            p1[i].y=Ry;
            GLdouble rx=r*cos(i*theta)+screenWidth/2;
            GLdouble ry=r*sin(i*theta)+screenHeight/2;
            p2[i].x=rx;
            p2[i].y=ry;
            glVertex2d(p1[i].x,p1[i].y);
            glVertex2d(p2[i].x,p2[i].y);
        }
        glEnd();
       for(int i=0;i<N;i+=2)
        {
            moveTo(p1[i].x,p1[i].y);
            lineTo(p1[(i+2)%N].x,p1[(i+2)%N].y);
    
        }
        for(int i=0;i<N;i+=2)
        {
            moveTo(p1[i].x,p1[i].y);
            lineTo(p2[(i+1)%N].x,p2[(i+1)%N].y);
            moveTo(p2[i+1].x,p2[i+1].y);
            lineTo(p1[(i+2)%N].x,p1[(i+2)%N].y);
        }
        glFlush();
    }
    void myInit(void)
    {
        glClearColor(1.0,1.0,1.0,0.0);      //background color
        glColor3f(0.0f,0.2f,0.6f);          //point color
        glPointSize(3.0);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluOrtho2D(0.0,500,0.0,500);
    }
    int main(int argc,char ** argv)
    {
        glutInit(&argc,argv);
        glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
        glutInitWindowPosition(0,0);
        glutInitWindowSize(500,500);
        glutCreateWindow("内外圆多边形");
        glutDisplayFunc(photo);
        myInit();
        glutMainLoop();
        return 0;
    }

    结果

     3.2.9图B     仅将a图代码中的N改为10即可

    //3.2.9图b
    
    #include <windows.h>
    #include <gl/gl.h>
    #include <gl/glu.h>
    #include <gl/glut.h>
    #include <iostream>
    #include <math.h>
    
    using namespace std;
    
    const int N=10;
    const double pi=3.1415926;
    const double theta=2*pi/N;
    const double R=200;
    const double r=50;
    const double screenWidth=500;
    const double screenHeight=500;
    
    class point
    {
      public:
        GLdouble x;
        GLdouble y;
        void setp(GLdouble _x,GLdouble _y){x=_x;y=_y;};
    
    };
    point sp;
    void moveTo(GLdouble x,GLdouble y)
    {
       sp.setp(x,y);
    }
    void lineTo(GLdouble x,GLdouble y)
    {
        glBegin(GL_LINES);
            glVertex2d(sp.x,sp.y);
            glVertex2d(x,y);
        glEnd();
        sp.x=x;
        sp.y=y;
    }
    void photo(void)
    {
        class point p1[N];
        class point p2[N];
        glClear(GL_COLOR_BUFFER_BIT);
        glBegin(GL_POINTS);
        for(int i=0;i<N;i++)
        {
            GLdouble Rx=R*cos(i*theta)+screenWidth/2;
            GLdouble Ry=R*sin(i*theta)+screenHeight/2;
            p1[i].x=Rx;
            p1[i].y=Ry;
            GLdouble rx=r*cos(i*theta)+screenWidth/2;
            GLdouble ry=r*sin(i*theta)+screenHeight/2;
            p2[i].x=rx;
            p2[i].y=ry;
            glVertex2d(p1[i].x,p1[i].y);
            glVertex2d(p2[i].x,p2[i].y);
        }
        glEnd();
       for(int i=0;i<N;i+=2)
        {
            moveTo(p1[i].x,p1[i].y);
            lineTo(p1[(i+2)%N].x,p1[(i+2)%N].y);
    
        }
        for(int i=0;i<N;i+=2)
        {
            moveTo(p1[i].x,p1[i].y);
            lineTo(p2[(i+1)%N].x,p2[(i+1)%N].y);
            moveTo(p2[i+1].x,p2[i+1].y);
            lineTo(p1[(i+2)%N].x,p1[(i+2)%N].y);
        }
        glFlush();
    }
    void myInit(void)
    {
        glClearColor(1.0,1.0,1.0,0.0);      //background color
        glColor3f(0.0f,0.2f,0.6f);          //point color
        glPointSize(3.0);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluOrtho2D(0.0,500,0.0,500);
    }
    int main(int argc,char ** argv)
    {
        glutInit(&argc,argv);
        glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
        glutInitWindowPosition(0,0);
        glutInitWindowSize(500,500);
        glutCreateWindow("内外圆多边形");
        glutDisplayFunc(photo);
        myInit();
        glutMainLoop();
        return 0;
    }

    代码结果

     

     3.29图c    修改N  去掉外框线

    //3.2.9图c
    
    #include <windows.h>
    #include <gl/gl.h>
    #include <gl/glu.h>
    #include <gl/glut.h>
    #include <iostream>
    #include <math.h>
    
    using namespace std;
    
    const int N=14;
    const double pi=3.1415926;
    const double theta=2*pi/N;
    const double R=200;
    const double r=50;
    const double screenWidth=500;
    const double screenHeight=500;
    
    class point
    {
      public:
        GLdouble x;
        GLdouble y;
        void setp(GLdouble _x,GLdouble _y){x=_x;y=_y;};
    
    };
    point sp;
    void moveTo(GLdouble x,GLdouble y)
    {
       sp.setp(x,y);
    }
    void lineTo(GLdouble x,GLdouble y)
    {
        glBegin(GL_LINES);
            glVertex2d(sp.x,sp.y);
            glVertex2d(x,y);
        glEnd();
        sp.x=x;
        sp.y=y;
    }
    void photo(void)
    {
        class point p1[N];
        class point p2[N];
        glClear(GL_COLOR_BUFFER_BIT);
        glBegin(GL_POINTS);
        for(int i=0;i<N;i++)
        {
            GLdouble Rx=R*cos(i*theta)+screenWidth/2;
            GLdouble Ry=R*sin(i*theta)+screenHeight/2;
            p1[i].x=Rx;
            p1[i].y=Ry;
            GLdouble rx=r*cos(i*theta)+screenWidth/2;
            GLdouble ry=r*sin(i*theta)+screenHeight/2;
            p2[i].x=rx;
            p2[i].y=ry;
            glVertex2d(p1[i].x,p1[i].y);
            glVertex2d(p2[i].x,p2[i].y);
        }
        glEnd();
         for(int i=0;i<N;i+=2)
        {
            moveTo(p1[i].x,p1[i].y);
            lineTo(p2[(i+1)%N].x,p2[(i+1)%N].y);
            moveTo(p2[i+1].x,p2[i+1].y);
            lineTo(p1[(i+2)%N].x,p1[(i+2)%N].y);
        }
        glFlush();
    }
    void myInit(void)
    {
        glClearColor(1.0,1.0,1.0,0.0);      //background color
        glColor3f(0.0f,0.2f,0.6f);          //point color
        glPointSize(3.0);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluOrtho2D(0.0,500,0.0,500);
    }
    int main(int argc,char ** argv)
    {
        glutInit(&argc,argv);
        glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
        glutInitWindowPosition(0,0);
        glutInitWindowSize(500,500);
        glutCreateWindow("内外圆多边形");
        glutDisplayFunc(photo);
        myInit();
        glutMainLoop();
        return 0;
    }

    结果图

    3.29图d   多加上一个画内圆的代码段

    //3.2.9图c
    
    #include <windows.h>
    #include <gl/gl.h>
    #include <gl/glu.h>
    #include <gl/glut.h>
    #include <iostream>
    #include <math.h>
    
    using namespace std;
    
    const int N=14;
    const double pi=3.1415926;
    const double theta=2*pi/N;
    const double R=200;
    const double r=50;
    const double screenWidth=500;
    const double screenHeight=500;
    
    class point
    {
      public:
        GLdouble x;
        GLdouble y;
        void setp(GLdouble _x,GLdouble _y){x=_x;y=_y;};
    
    };
    point sp;
    void moveTo(GLdouble x,GLdouble y)
    {
       sp.setp(x,y);
    }
    void lineTo(GLdouble x,GLdouble y)
    {
        glBegin(GL_LINES);
            glVertex2d(sp.x,sp.y);
            glVertex2d(x,y);
        glEnd();
        sp.x=x;
        sp.y=y;
    }
    void photo(void)
    {
        class point p1[N];
        class point p2[N];
        glClear(GL_COLOR_BUFFER_BIT);
        glBegin(GL_POINTS);
        for(int i=0;i<N;i++)
        {
            GLdouble Rx=R*cos(i*theta)+screenWidth/2;
            GLdouble Ry=R*sin(i*theta)+screenHeight/2;
            p1[i].x=Rx;
            p1[i].y=Ry;
            GLdouble rx=r*cos(i*theta)+screenWidth/2;
            GLdouble ry=r*sin(i*theta)+screenHeight/2;
            p2[i].x=rx;
            p2[i].y=ry;
            glVertex2d(p1[i].x,p1[i].y);
            glVertex2d(p2[i].x,p2[i].y);
        }
        glEnd();
       for(int i=0;i<N;i+=2)//画外框
        {
            moveTo(p1[i].x,p1[i].y);
            lineTo(p1[(i+2)%N].x,p1[(i+2)%N].y);
    
        }
        for(int i=0;i<N;i+=2)//画内角
        {
            moveTo(p1[i].x,p1[i].y);
            lineTo(p2[(i+1)%N].x,p2[(i+1)%N].y);
            moveTo(p2[i+1].x,p2[i+1].y);
            lineTo(p1[(i+2)%N].x,p1[(i+2)%N].y);
        }
        //画内圆
        glBegin(GL_POINTS);
        for(double i=0.0;i<=2*pi;i+=0.05)
            glVertex2d(r*cos(i)+screenWidth/2,r*sin(i)+screenHeight/2);
        glEnd();
        glFlush();
    }
    void myInit(void)
    {
        glClearColor(1.0,1.0,1.0,0.0);      //background color
        glColor3f(0.0f,0.2f,0.6f);          //point color
        glPointSize(3.0);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluOrtho2D(0.0,500,0.0,500);
    }
    int main(int argc,char ** argv)
    {
        glutInit(&argc,argv);
        glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
        glutInitWindowPosition(0,0);
        glutInitWindowSize(500,500);
        glutCreateWindow("内外圆多边形");
        glutDisplayFunc(photo);
        myInit();
        glutMainLoop();
        return 0;
    }

    练习3.4.1   

     3.4.2证明

     图片3.30  某大学的标志

    给定一点

    //3.4.3  校标
    
    #include <windows.h>
    #include <gl/gl.h>
    #include <gl/glu.h>
    #include <gl/glut.h>
    #include <iostream>
    #include <math.h>
    
    using namespace std;
    
    const double screenWidth=500;
    const double screenHeight=500;
    
    int j=0;//声明一个全局变量
    
    class point
    {
      public:
        GLdouble x;
        GLdouble y;
        void setp(GLdouble _x,GLdouble _y){x=_x;y=_y;};
    };
    void photo(void)
    {
        point p[6]; //定义对象数组  并且初始化   
        p[0].x=0;
        p[0].y=20;
        p[1].x=-100;
        p[1].y=80;
        p[2].x=-100;
        p[2].y=200;
        p[3].x=0;
        p[3].y=140;
        p[4].x=100;
        p[4].y=200;
        p[5].x=100;
        p[5].y=80;
        int N=3;
        double pi=3.1415926;
        double theta=2*pi/N;
        //开始画图
        glClear(GL_COLOR_BUFFER_BIT);
        for(int j=0;j<3;j++)        //j定义为全局变量    否则不能通过编译
        {
            glBegin(GL_LINE_LOOP);
              for(int i=0;i<6;i++)
    glVertex2d((cos(theta
    *j)*p[i].x-sin(theta*j)*p[i].y)+screenWidth/2,(sin(theta*j)*p[i].x+cos(theta*j)*p[i].y)+screenHeight/2); glEnd(); } glFlush(); } void myInit(void) { glClearColor(1.0,1.0,1.0,0.0); //background color glColor3f(0.0f,0.2f,0.6f); //point color glPointSize(3.0); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D(0.0,500,0.0,500); } int main(int argc,char ** argv) { glutInit(&argc,argv); glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB); glutInitWindowPosition(0,0); glutInitWindowSize(500,500); glutCreateWindow("校标"); glutDisplayFunc(photo); myInit(); glutMainLoop(); return 0; }

     3.4.3 绘制圆与圆弧

     

     圆心:c

    半径:R

    开始角度:a

    展开角度:b   

      b为负值  则顺时针画图

      b为正值  则逆时针画图

    展开的角度是360度

     drawCirlce()   通过指定圆心和半径来绘制,还有其他的方法来描述圆,常见的方式是:

      1.已知圆心以及一个院上的点。    利用圆心以及一个圆上的点  计算两点的距离即半径

      2.给定圆必须经过的三个点。  三个不共线的点可以唯一确定一个圆

    画圆案例2  

    //3.4.3  圆外切
    
    #include <windows.h>
    #include <gl/gl.h>
    #include <gl/glu.h>
    #include <gl/glut.h>
    #include <iostream>
    #include <math.h>
    
    using namespace std;
    
    const double screenWidth=500;
    const double screenHeight=500;
    
    class point
    {
      public:
        GLdouble x;
        GLdouble y;
        void setp(GLdouble _x,GLdouble _y){x=_x;y=_y;};
    };
    void photo(void)
    {
        double r=100;
        double x;
        int w=150;
        int h=120;
        glClear(GL_COLOR_BUFFER_BIT);
            glBegin(GL_POINTS);
            for(x=-100;x<100;x+=0.05)
            {
             glVertex2d(x+w,sqrt(r*r-x*x)+h);
             glVertex2d(x+w,-sqrt(r*r-x*x)+h);
            }
            glVertex2d(w,h);
            glEnd();
        glFlush();
    }
    void myInit(void)
    {
        glClearColor(1.0,1.0,1.0,0.0);      //background color
        glColor3f(0.0f,0.2f,0.6f);          //point color
        glPointSize(3.0);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluOrtho2D(0.0,500,0.0,500);
    }
    int main(int argc,char ** argv)
    {
        glutInit(&argc,argv);
        glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
        glutInitWindowPosition(0,0);
        glutInitWindowSize(500,500);
        glutCreateWindow("画弧和圆");
        glutDisplayFunc(photo);
        myInit();
        glutMainLoop();
        return 0;
    }

     画圆案例3

    //3.4.3  圆外切   给定一个两个圆心  和两个圆的交点    画两个圆和一条切线
    
    #include <windows.h>
    #include <gl/gl.h>
    #include <gl/glu.h>
    #include <gl/glut.h>
    #include <iostream>
    #include <math.h>
    
    using namespace std;
    
    const double screenWidth=500;
    const double screenHeight=500;
    int w=80;//位移
    int h=80;
    class point
    {
      public:
        GLdouble x;
        GLdouble y;
        void setp(GLdouble _x,GLdouble _y){x=_x;y=_y;};
    };
    
    double getr(point p1,point p2)//获取半径的平方
    {
        double r=sqrt((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y));
        return r;
    }
    void line(point p1,point p2)//p1为圆心,p2为圆上点   直线过p2点
    {
        double k,b;
        k=-(p2.x-p1.x)/(p2.y-p1.y);
        b=p2.y-k*p2.x;
        glBegin(GL_POINTS);
            for(double x=10;x<200;x++)
            glVertex2d(x+w,k*x+b+h);
        glEnd();
    }
    void photo(point p1,point p2)    //根据两个点画圆   p1为圆心   p2为圆上的点
    {
        double r=getr(p1,p2);
        double x;
    
        glBegin(GL_POINTS);
            for(x=p1.x-r;x<=p1.x+r;x+=0.05)
            {
                glVertex2d(x+w,sqrt(r*r-(x-p1.x)*(x-p1.x))+p1.y+h);
                glVertex2d(x+w,-sqrt(r*r-(x-p1.x)*(x-p1.x))+p1.y+h);
            }
            glVertex2d(p1.x+w,p1.y+h);
        glEnd();
     }
     void mydisplay(void)
     {
        class point p1;//初始化 三个对象
        p1.x=50;
        p1.y=50;
        point p2;
        p2.x=120;
        p2.y=120;
        point p3;
        p3.x=180;
        p3.y=160;
        glClear(GL_COLOR_BUFFER_BIT);
            photo(p1,p2);
            photo(p3,p2);
            line(p1,p2);
        glFlush();
     }
    void myInit(void)
    {
        glClearColor(1.0,1.0,1.0,0.0);      //background color
        glColor3f(0.0f,0.2f,0.6f);          //point color
        glPointSize(3.0);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluOrtho2D(0.0,500,0.0,500);
    }
    int main(int argc,char ** argv)
    {
        glutInit(&argc,argv);
        glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
        glutInitWindowPosition(0,0);
        glutInitWindowSize(500,500);
        glutCreateWindow("画弧和圆");
        glutDisplayFunc(mydisplay);
        myInit();
        glutMainLoop();
        return 0;
    }

    执行结果:

     3.4.4曲线的逐次细化

      逐次细化一个简单的曲线,可以递归形成非常复杂的曲线。  例如koch曲线   逐渐逼近真实的曲线   

      

        将kn的每一条线段平均分为3的段,然后将中间的那段用一个等边三角形来提高代替,采用递归的方式,每一线段的长度变为原来的4/3,所以总的曲线长度也是它上一代的4/3.因此kn的总长度为(4/3)的n次幂。

     3.5曲线的参数形式

    描述曲线的形状主要有两种方法:

    隐式法和参数形式

     隐式法:使用函数f(x,y)来描述曲线    并且提供xy之间的关系       

      点在曲线上的条件:f(x,y)=0      

      一类曲线  曲线的内部和外部是有意义的,此种情况下    f(x,y)也被叫做内部-外部函数   其意义是:

        f(x,y)=0    对应所有在曲线上的点 (x,y)

        f(x,y)>0    对所有在曲线外的点(x,y)

        f(x,y)<0    对所有在曲线内的点(x,y) 

         曲线对x是单值   那么   g(x)对于每一个x   仅有一个g(x)     可以写成f(x,y)=y-g(x)

      曲线对y是单值, 存在函数h()   使得曲线上的所有点满足x=h(y)

      还有对于x和y都不是单值的:f(x,y)=0  不能写成y=g(x)   或者 x=h(y)的形式   可以表示成:

        y=+-根号下(r^2-x^2)   这里为两个函数    一个是正号,另一个是负号

    3.5.1曲线的参数形式

      当参数取不同值的时候,会产生出曲线上不同的点。推荐使用       以时间t的运动轨迹

      粒子沿着曲线运动的路径由两个函数x()和y()来确定,如果是三维  则有三个函数  x()      y()     z()    他们确定粒子在时刻t的位置。

      参数t通常被看作是时间,而曲线本身就是粒子随着时间在某一个区间内的变化所经过的点。

      通常证明隐式形式和参数形式相同   将参数形式带入隐式形式即可    即从参数形式求隐式形式

    3.5.2  绘制参数形式

      根据p(t)=(x(t),y(t))      其中t从0变化到T    我们只需要用非常紧凑的间隔采集p(t)的样本   然后连接成折线   近似的逼近曲线

      时间数组 t[i]     i=0 1 2 3...  

    glBegin(GL_LINES);
        for(int i=0;i<n;i++)
        glVertex2f(x(t[i]),y(t[i]));
    glEnd();

      案例绘制椭圆  

    glBegin(GL_LINES);
        for(double t=0;t<2*pi;t+=2*pi/n)//将2pi   n等分  越细分曲线越光滑
        glVertex2f(W*cos(t),H*sin(t));
    glEnd();

     3.5.4  样例曲线代码

    //3.4.3  圆外切   给定一个两个圆心  和两个圆的交点    画两个圆和一条切线
    
    #include <windows.h>
    #include <gl/gl.h>
    #include <gl/glu.h>
    #include <gl/glut.h>
    #include <iostream>
    #include <math.h>
    
    using namespace std;
    
    const double screenWidth=500;
    const double screenHeight=500;
    int w=180;//位移
    int h=80;
    const double pi=3.141592;
    const int n=360;
    
    
     void mydisplay(void)
     {
        glClear(GL_COLOR_BUFFER_BIT);
          glBegin(GL_LINE_LOOP);
          for(double t=0.0;t<2*pi;t+=2*pi/n)
            glVertex2d(w*cos(t)+screenWidth/2,h*sin(t)+screenHeight/2);
          glEnd();
        glFlush();
     }
    
    void myInit(void)
    {
        glClearColor(1.0,1.0,1.0,0.0);      //background color
        glColor3f(0.0f,0.2f,0.6f);          //point color
        glPointSize(3.0);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluOrtho2D(0.0,500,0.0,500);
    }
    int main(int argc,char ** argv)
    {
        glutInit(&argc,argv);
        glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
        glutInitWindowPosition(0,0);
        glutInitWindowSize(500,500);
        glutCreateWindow("画椭圆");
        glutDisplayFunc(mydisplay);
        myInit();
        glutMainLoop();
        return 0;
    }

    执行结果

     

     3.5.5   画图

    //3.4.3  圆外切   给定一个两个圆心  和两个圆的交点    画两个圆和一条切线
    
    #include <windows.h>
    #include <gl/gl.h>
    #include <gl/glu.h>
    #include <gl/glut.h>
    #include <iostream>
    #include <math.h>
    
    using namespace std;
    
    const double screenWidth=500;
    const double screenHeight=500;
    int w=180;//位移
    int h=140;
    const float f=h/w;
    double d=0.5;
    double t=d*f;
    
    
    const double pi=3.141592;
    const int n=360;
    const float color1[3]={1.0,1.0,1.0};
    const float color2[3]={0.0,0.0,0.0};
    void drawEllipse(int w,int h,const float * clr)//画圆并填充
    {
        if(w!=h)
        {
            glBegin(GL_POINTS);
            for(;w>0&&h>0;w-=d,h-=t)
           {
                glColor3f(clr[0],clr[1],clr[2]);
                for(double t=0.0;t<2*pi;t+=2*pi/n)
                glVertex2d(w*cos(t)+screenWidth/2,h*sin(t)+screenHeight/2);
            }
            glEnd();
        }
    
        if(w==h)
        {
            glBegin(GL_POINTS);
            for(;w>0&&h>0;w-=d)
            {
                glColor3f(clr[0],clr[1],clr[2]);
                for(double t=0.0;t<2*pi;t+=2*pi/n)
                glVertex2d(w*cos(t)+screenWidth/2,w*sin(t)+screenHeight/2);
            }
            glEnd();
        }
    }
     void mydisplay(void)
     {
        glClear(GL_COLOR_BUFFER_BIT);
            drawEllipse(w,h,color2);
            drawEllipse(h-5,h-5,color1);
            drawEllipse(h-10,h-50,color2);
            drawEllipse(h-55,h-55,color1);
        glFlush();
     }
    
    void myInit(void)
    {
        glClearColor(1.0,1.0,1.0,0.0);      //background color
        glPointSize(3.0);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluOrtho2D(0.0,500,0.0,500);
    }
    int main(int argc,char ** argv)
    {
        glutInit(&argc,argv);
        glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
        glutInitWindowPosition(0,0);
        glutInitWindowSize(500,500);
        glutCreateWindow("画椭圆");
        myInit();
        glutDisplayFunc(mydisplay);
        glutMainLoop();
        return 0;
    }

    执行结果

     3.5.3极坐标形式

    用来表示和绘制一些有趣曲线

     极坐标画圆

    //3.4.3  圆外切   给定一个两个圆心  和两个圆的交点    画两个圆和一条切线
    
    #include <windows.h>
    #include <gl/gl.h>
    #include <gl/glu.h>
    #include <gl/glut.h>
    #include <iostream>
    #include <math.h>
    
    using namespace std;
    
    const double screenWidth=500;
    const double screenHeight=500;
    double pi=3.1415926;
    
    void drawEllipse(double k)//极坐标画圆
    {
       double theta=0;
         glBegin(GL_POINTS);
            for(;theta<=2*pi;theta+=0.01)
            {
               glVertex2d(k*cos(theta)+screenWidth/2,k*sin(theta)+screenHeight/2);
            }
        glEnd();
    }
     void mydisplay(void)
     {
        glClear(GL_COLOR_BUFFER_BIT);
            drawEllipse(200);
        glFlush();
     }
    
    void myInit(void)
    {
        glClearColor(1.0,1.0,1.0,0.0);      //background color
        glPointSize(3.0);
        glColor3f(1.0,0.0,0.0);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluOrtho2D(0.0,500,0.0,500);
    }
    int main(int argc,char ** argv)
    {
        glutInit(&argc,argv);
        glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
        glutInitWindowPosition(0,0);
        glutInitWindowSize(500,500);
        glutCreateWindow("极坐标画圆");
        glutDisplayFunc(mydisplay);
        myInit();
        glutMainLoop();
        return 0;
    }

    执行结果

    极坐标画心形

    替换上面的函数代码段

    void drawEllipse(double k)//极坐标画圆
    {
       double theta=0;
         glBegin(GL_POINTS);
            for(;theta<=2*pi;theta+=0.01)
            {
                double f=k*(1+cos(theta));
                glVertex2d(f*cos(theta)+screenWidth/3,f*sin(theta)+screenHeight/2);
            }
        glEnd();
    }

    执行结果

     玫瑰曲线   图3.45

    代码段替换

    void drawEllipse(double k,int n)//极坐标画圆   n为花瓣
    {
       double theta=0;
         glBegin(GL_LINES);
            for(;theta<=2*pi;theta+=0.00001)
            {
                double f=k*cos(n*theta);
                glVertex2d(f*cos(theta)+screenWidth/2,f*sin(theta)+screenHeight/2);
                glVertex2d(f*cos(theta+0.00001)+screenWidth/2,f*sin(theta+0.01)+screenHeight/2);
            }
        glEnd();
    }
     void mydisplay(void)
     {
        glClear(GL_COLOR_BUFFER_BIT);
            drawEllipse(200,8);
        glFlush();
     }

    执行结果

     阿基米德螺旋线

    替换代码段

    void drawEllipse(double k,int n)//极坐标画圆   n为圈数
    {
       double theta=0;
         glBegin(GL_POINTS);
            for(;theta<=n*pi;theta+=0.01)
            {
                double f=k*theta;
                glVertex2d(f*cos(theta)+screenWidth/2,f*sin(theta)+screenHeight/2);
            }
        glEnd();
    }

     以上各类函数如下:

    圆锥曲线代码

    void drawEllipse(double e)//极坐标画圆   n为圈数
    {
       double theta=0;
         glBegin(GL_POINTS);
            for(;theta<=2*pi;theta+=0.0001)
            {
                double f1=1/(1-e*cos(theta));
                //double f2=1/(1+e*cos(theta));
                glVertex2d(f1*cos(theta)+screenWidth/4,f1*sin(theta)+screenHeight/2);
                //glVertex2d(f2*cos(theta)+screenWidth/2,f2*sin(theta)+screenHeight/2);
            }
        glEnd();
    }

    对数螺旋线

    void drawEllipse(double e)//极坐标画圆   n为圈数    调用时  e的值需要大于1
    {
       double theta=0;
       double k=0.8;
       double a=0.6;
         glBegin(GL_POINTS);
            for(;theta<=16*pi;theta+=0.01)
            {
                double f1=k*pow(e,a*theta);//e的a*theta次幂
                //double f2=1/(1+e*cos(theta));
                glVertex2d(f1*cos(theta)+screenWidth/2,f1*sin(theta)+screenHeight/2);
                //glVertex2d(f2*cos(theta)+screenWidth/2,f2*sin(theta)+screenHeight/2);
            }
        glEnd();
    }

    双曲线

    void drawEllipse(double e,double p)//极坐标画圆   n为圈数                                   e大于1
    {
       double theta=0;
    
         glBegin(GL_POINTS);
            for(;theta<=2*pi;theta+=0.001)
            {
                double f1=e*p/(1-e*cos(theta));//圆锥曲线通用方程  p为焦点到准线的距离     f1表示数学中极坐标的径向距离
                glVertex2d(f1*cos(theta)+screenWidth/2,f1*sin(theta)+screenHeight/2);
            }
        glEnd();
        glBegin(GL_LINES);  //x轴
            glVertex2d(0,250);
            glVertex2d(500,250);
        glEnd();
        glBegin(GL_LINES);  //y轴
            glVertex2d(250,0);
            glVertex2d(250,500);
        glEnd();
    }

     

     由上例可知  双曲线的右焦点为极坐标系的极点   用到的公式如下

     同理可得椭圆的极坐标画图代码及图像

    void drawEllipse(double e,double p)//极坐标画圆   n为圈数     e小于1
    {
       double theta=0;
    
         glBegin(GL_POINTS);
            for(;theta<=2*pi;theta+=0.001)
            {
                double f1=e*p/(1-e*cos(theta));//圆锥曲线通用方程  p为焦点到准线的距离     f1表示数学中极坐标的径向距离
                glVertex2d(f1*cos(theta)+screenWidth/2,f1*sin(theta)+screenHeight/2);
            }
        glEnd();
        glBegin(GL_LINES);  //x轴
            glVertex2d(0,250);
            glVertex2d(500,250);
        glEnd();
        glBegin(GL_LINES);  //y轴
            glVertex2d(250,0);
            glVertex2d(250,500);
        glEnd();
    }

     可以看出 椭圆的左焦点为  极坐标的极点  

    同理上面代码中e=1时   是抛物线    开口向右   极点为焦点

      

  • 相关阅读:
    hdu1754:I Hate It
    hdu1166
    bzoj1642:挤奶时间
    线段树
    bzoj1699:排队
    bzoj3438: 小M的作物
    bzoj2127: happiness
    bzoj2768[JLOI2010]冠军调查
    bzoj1070[SCOI2007]修车
    bzoj1305[CQOI2009]dance跳舞
  • 原文地址:https://www.cnblogs.com/dongguolei/p/10038525.html
Copyright © 2020-2023  润新知