矩形裁剪算法_pyopengl

环境准备:

Python版本是3.5.1。使用pip命令:pip install pyopengl 安装pyopengl模块。

图形学期末设计,不知道用opengl或webgl做什么炫酷的效果,只好做算法了,悲剧的写了500多行,缺点是裁剪算法未封装成函数。

代码如下:

#encoding='utf-8'
#python3.5.1
#author by 张政伟 2016/6/16
#矩形裁剪算法
from OpenGL.GLUT import *
from OpenGL.GL import *
import sys
blue=(0.0,0.0,1.0)
green=(0.0,1.0,0.0)
red=(1.0,0.0,0.0)
color=blue
winx=400 #窗口宽度
winy=400 #窗口高度
l1=[];#存储坐标
class point:
    x=0 #x坐标
    y=0 #y坐标
    pl=0 #相对于矩形裁剪区域左边,此点的位置,0为内,1为外
    pt=0 #相对于矩形裁剪区域上边,此点的位置,0为内,1为外
    pr=0 #相对于矩形裁剪区域右边,此点的位置,0为内,1为外
    pb=0 #相对于矩形裁剪区域下边,此点的位置,0为内,1为外
    def __init__(self,x,y,pl,pt,pr,pb):
        self.x=x
        self.y=y
        self.pl=pl
        self.pt=pt
        self.pr=pr
        self.pb=pb

#窗口左上角为(0,0),而PyOpengl画图以窗口中心为(0,0)且最大x坐标与y坐标都是100。
#因此需要将鼠标获取的坐标转换成PyOpengl画图坐标。
def translate(point):
    a=winx/2
    b=winy/2
    if point.x < a and point.y < b:
        point.x=(point.x/a)*100-100
        point.y=100-(point.y/b)*100
    elif point.x > a and point.y < b:
        point.x=((point.x-a)/a)*100
        point.y=100-(point.y/b)*100
    elif point.x < a and point.y > b:
        point.x=(point.x/a)*100-100
        point.y=((point.y-b)/b)*100*(-1)
    else:
        point.x=((point.x-a)/a)*100
        point.y=((point.y-b)/b)*100*(-1)
def display():
    glClearColor(0.0,0.0,0.0,0.0)  #背景色=黑色,RGBA全为0
    glClear(GL_COLOR_BUFFER_BIT)   #清除颜色缓冲区
    glColor3fv(color)              #设置下面绘制物体的颜色
    #f表示参数类型为浮点类型,v表示接受的参数为数组形式
    #glRectf(-10.0,-20.0,20.0,10.0)
    #绘制坐标系
    glColor3f(1.0, 1.0, 1.0)
    glBegin(GL_LINES)
    glVertex2f(0.0, 0.0)
    glVertex2f(0.0, 95.0)
    glVertex2f(0.0, 95.0)
    glVertex2f(4.0, 92.0)
    glVertex2f(0.0, 95.0)
    glVertex2f(-4.0, 92.0)
    glVertex2f(0.0, 0.0)
    glVertex2f(0.0, -95.0)
    glVertex2f(0.0, 0.0)
    glVertex2f(95.0,0.0)
    glVertex2f(95.0,0.0)
    glVertex2f(92.0,4.0)
    glVertex2f(95.0,0.0)
    glVertex2f(92.0,-4.0)
    glVertex2f(0.0, 0.0)
    glVertex2f(-95.0,0.0)
    glEnd()
    glColor3f(0.0,0.0,1.0)
    glBegin(GL_POINTS);
    glVertex2i(0,0);
    glEnd();
    glFlush()
def reshape(winx,winy):
    glViewport(0,0,winx,winy)      #定义相对视窗大小(像素范围)
    glMatrixMode(GL_PROJECTION)    #选择投影矩阵
    glLoadIdentity()               #读取规范化的单位矩阵
    glOrtho(-100.0,100.0, -100.0,100.0, 0.0,100.0)
                                   #定义空间坐标系范围
    glMatrixMode(GL_MODELVIEW)     #选择模型视图矩阵
    glLoadIdentity()
def key(key,mousex,mousey):
    global color
    if (key==b'q'):                 #按下q按键时
        print('退出')
        glutDestroyWindow(winid)   #根据ID结束窗口
        sys.exit()
    elif (key==b'e'):
        l1.clear()
        print('初始化界面')
        glutPostRedisplay()        #重绘,将调用display
    elif (key==b'g'):
        #以绿线画裁剪后图形并输出裁剪后坐标

        if l1[0].x<l1[1].x:
            #矩形裁剪区域:左下点的坐标
            plb=point(l1[0].x,l1[0].y,0,0,0,0)
            #矩形裁剪区域:右上点的坐标
            prt=point(l1[1].x,l1[1].y,0,0,0,0)
        else:
            #矩形裁剪区域:左下点的坐标
            plb=point(l1[1].x,l1[1].y,0,0,0,0)
            #矩形裁剪区域:右上点的坐标
            prt=point(l1[0].x,l1[0].y,0,0,0,0)
        #输出
        print('裁剪区域左下点坐标:')
        print(plb.x,plb.y)
        print('裁剪区域右上点坐标:')
        print(prt.x,prt.y)
        #被裁剪区域顶点坐标
        l=l1[2:]
        #函数:得到被裁剪区域顶点坐标相对于裁剪区域四条边的位置
        def judgePositon(point):
            #判断左边
            if(i.x<plb.x):
                i.pl=1
            else:
                i.pl=0
            #判断上边
            if(i.y<prt.y):
                i.pt=0
            else:
                i.pt=1
            #判断右边
            if(i.x<prt.x):
                i.pr=0
            else:
                i.pr=1
            #判断下边
            if(i.y<plb.y):
                i.pb=1
            else:
                i.pb=0

        #调用函数,完全初始化被裁减区域顶点坐标
        for i in l1:
            judgePositon(i)
        #测试输出被裁剪区域顶点坐标
        print("init:")
        for i in l:
            print(i.x,i.y,i.pl,i.pt,i.pr,i.pb)
        #列表:存储裁剪后坐标
        l2=[]
        #左边裁剪
        for i in range(0,len(l)):
            if(i==len(l)-1):
                if(l[i].pl==0):
                    #都在内部,保留第二个顶点
                    if(l[0].pl==0):
                        l2.append(l[0])
                    #一内一外,保留交点
                    else:
                        k=(l[i].y-l[0].y)/(l[i].x-l[0].x)
                        b=l[i].y-k*l[i].x
                        x=plb.x
                        y=x*k+b
                        temp=point(x,y,0,0,0,0)
                        l2.append(temp)
                else:
                    #一外一内,保留交点与内
                    if(l[0].pl==0):
                        k=(l[i].y-l[0].y)/(l[i].x-l[0].x)
                        b=l[i].y-k*l[i].x
                        x=plb.x
                        y=x*k+b
                        temp=point(x,y,0,0,0,0)
                        l2.append(temp)
                        l2.append(l[0])
                    #都在外部,全部舍弃
                    else:
                        pass

            else:
                if(l[i].pl==0):
                    #都在内部,保留第二个顶点
                    if(l[i+1].pl==0):
                        l2.append(l[i+1])
                    #一内一外,保留交点
                    else:
                        k=(l[i].y-l[i+1].y)/(l[i].x-l[i+1].x)
                        b=l[i].y-k*l[i].x
                        x=plb.x
                        y=x*k+b
                        temp=point(x,y,0,0,0,0)
                        l2.append(temp)
                else:
                    #一外一内,保留交点与内
                    if(l[i+1].pl==0):
                        k=(l[i].y-l[i+1].y)/(l[i].x-l[i+1].x)
                        b=l[i].y-k*l[i].x
                        x=plb.x
                        y=x*k+b
                        temp=point(x,y,0,0,0,0)
                        l2.append(temp)
                        l2.append(l[i+1])
                    #都在外部,全部舍弃
                    else:
                        pass
        #初始化左裁剪后顶点坐标相对裁剪区域的位置
        for i in l2:
            judgePositon(l2)
        #输出左裁剪后顶点坐标
        print("leftClip:")
        for i in l2:
            print(i.x,i.y,i.pl,i.pt,i.pr,i.pb)

        #上边裁剪
        #清除列表l,用来存储上边裁剪后顶点坐标
        l.clear()
        for i in range(0,len(l2)):
            if(i==len(l2)-1):
                if(l2[i].pt==0):
                    #都在内部,保留第二个顶点
                    if(l2[0].pt==0):
                        #l.append(l2[i])
                        l.append(l2[0])
                    #一内一外,保留交点
                    else:
                        if(l2[i].x==l2[0].x):
                            x=l2[i].x
                            y=prt.y
                            temp=point(x,y,0,0,0,0)
                            l.append(temp)
                        else:
                            k=(l2[i].y-l2[0].y)/(l2[i].x-l2[0].x)
                            b=l2[i].y-k*l2[i].x
                            y=prt.y
                            if k!=0:
                                x=(y-b)/k
                            temp=point(x,y,0,0,0,0)
                            l.append(temp)
                else:
                    #一外一内,保留交点与内
                    if(l2[0].pt==0):
                        if(l2[i].x==l2[0].x):
                            x=l2[i].x
                            y=prt.y
                            temp=point(x,y,0,0,0,0)
                            l.append(temp)
                            l.append(l2[0])
                        else:
                            k=(l2[i].y-l2[0].y)/(l2[i].x-l2[0].x)
                            b=l2[i].y-k*l2[i].x
                            y=prt.y
                            if k!=0:
                                x=(y-b)/k
                            temp=point(x,y,0,0,0,0)
                            l.append(temp)
                            l.append(l2[0])
                    #都在外部,全部舍弃
                    else:
                        pass

            else:
                if(l2[i].pt==0):
                    #都在内部,保留第二个顶点
                    if(l2[i+1].pt==0):
                        #l.append(l2[i])
                        l.append(l2[i+1])
                    #一内一外,保留交点
                    else:
                        if(l2[i].x==l2[i+1].x):
                            x=l2[i].x
                            y=prt.y
                            temp=point(x,y,0,0,0,0)
                            l.append(temp)
                        else:
                            k=(l2[i].y-l2[i+1].y)/(l2[i].x-l2[i+1].x)
                            b=l2[i].y-k*l2[i].x
                            y=prt.y
                            if k!=0:
                                x=(y-b)/k
                            temp=point(x,y,0,0,0,0)
                            l.append(temp)
                else:
                    #一外一内,保留交点与内
                    if(l2[i+1].pt==0):
                        if(l2[i].x==l2[i+1].x):
                            x=l2[i].x
                            y=prt.y
                            temp=point(x,y,0,0,0,0)
                            l.append(temp)
                            l.append(l2[i+1])
                        else:
                            k=(l2[i].y-l2[i+1].y)/(l2[i].x-l2[i+1].x)
                            b=l2[i].y-k*l2[i].x
                            y=prt.y
                            if k!=0:
                                x=(y-b)/k
                            temp=point(x,y,0,0,0,0)
                            l.append(temp)
                            l.append(l2[i+1])
                    #都在外部,全部舍弃
                    else:
                        pass
        #初始化上裁剪后顶点坐标相对裁剪区域的位置
        for i in l:
            judgePositon(l)
        #输出上裁剪后顶点坐标
        print("topClip:")
        for i in l:
            print(i.x,i.y,i.pl,i.pt,i.pr,i.pb)

        #右边裁剪
        #清除列表l2,用来存储上边裁剪后顶点坐标
        l2.clear()
        for i in range(0,len(l)):
            if(i==len(l)-1):
                if(l[i].pr==0):
                    #都在内部,保留第二顶点
                    if(l[0].pr==0):
                        l2.append(l[0])
                    #一内一外,保留交点
                    else:
                        k=(l[i].y-l[0].y)/(l[i].x-l[0].x)
                        b=l[i].y-k*l[i].x
                        x=prt.x
                        y=x*k+b
                        temp=point(x,y,0,0,0,0)
                        l2.append(temp)
                else:
                    #一外一内,保留交点与内
                    if(l[0].pr==0):
                        k=(l[i].y-l[0].y)/(l[i].x-l[0].x)
                        b=l[i].y-k*l[i].x
                        x=prt.x
                        y=x*k+b
                        temp=point(x,y,0,0,0,0)
                        l2.append(temp)
                        l2.append(l[0])
                    #都在外部,全部舍弃
                    else:
                        pass

            else:
                if(l[i].pr==0):
                    #都在内部,保留第二顶点
                    if(l[i+1].pr==0):
                        l2.append(l[i+1])
                    #一内一外,保留交点
                    else:
                        k=(l[i].y-l[i+1].y)/(l[i].x-l[i+1].x)
                        b=l[i].y-k*l[i].x
                        x=prt.x
                        y=x*k+b
                        temp=point(x,y,0,0,0,0)
                        l2.append(temp)
                else:
                    #一外一内,保留交点与内
                    if(l[i+1].pr==0):
                        k=(l[i].y-l[i+1].y)/(l[i].x-l[i+1].x)
                        b=l[i].y-k*l[i].x
                        x=prt.x
                        y=x*k+b
                        temp=point(x,y,0,0,0,0)
                        l2.append(temp)
                        l2.append(l[i+1])
                    #都在外部,全部舍弃
                    else:
                        pass
        #初始化右裁剪后顶点坐标相对裁剪区域的位置
        for i in l2:
            judgePositon(l2)
        #输出右裁剪后顶点坐标
        print("rightClip:")
        for i in l2:
            print(i.x,i.y,i.pl,i.pt,i.pr,i.pb)

        #下边裁剪
        #清除列表l,用来存储下边裁剪后顶点坐标
        l.clear()
        for i in range(0,len(l2)):
            if(i==len(l2)-1):
                if(l2[i].pb==0):
                    #都在内部,保留第二顶点
                    if(l2[0].pb==0):
                        #l.append(l2[i])
                        l.append(l2[0])
                    #一内一外,保留交点
                    else:
                        if(l2[i].x==l2[0].x):
                            x=l2[i].x
                            y=plb.y
                            temp=point(x,y,0,0,0,0)
                            l.append(temp)
                        else:
                            k=(l2[i].y-l2[0].y)/(l2[i].x-l2[0].x)
                            b=l2[i].y-k*l2[i].x
                            y=plb.y
                            if k!=0:
                                x=(y-b)/k
                            temp=point(x,y,0,0,0,0)
                            l.append(temp)
                else:
                    #一外一内,保留交点内
                    if(l2[0].pb==0):
                        if(l2[i].x==l2[0].x):
                            x=l2[i].x
                            y=plb.y
                            temp=point(x,y,0,0,0,0)
                            l.append(temp)
                            l.append(l2[0])
                        else:
                            k=(l2[i].y-l2[0].y)/(l2[i].x-l2[0].x)
                            b=l2[i].y-k*l2[i].x
                            y=plb.y
                            if k!=0:
                                x=(y-b)/k
                            temp=point(x,y,0,0,0,0)
                            l.append(temp)
                            l.append(l2[0])
                    #都在外部,全部舍弃
                    else:
                        pass

            else:
                if(l2[i].pb==0):
                    #都在内部,保留第二顶点
                    if(l2[i+1].pb==0):
                        #l.append(l2[i])
                        l.append(l2[i+1])
                    #一内一外,保留交点
                    else:
                        if(l2[i].x==l2[i+1].x):
                            x=l2[i].x
                            y=plb.y
                            temp=point(x,y,0,0,0,0)
                            l.append(temp)
                        else:
                            k=(l2[i].y-l2[i+1].y)/(l2[i].x-l2[i+1].x)
                            b=l2[i].y-k*l2[i].x
                            y=plb.y
                            if k!=0:
                                x=(y-b)/k
                            temp=point(x,y,0,0,0,0)
                            l.append(temp)
                else:
                    #一外一内,保留交点与内
                    if(l2[i+1].pb==0):
                        if(l2[i].x==l2[i+1].x):
                            x=l2[i].x
                            y=plb.y
                            temp=point(x,y,0,0,0,0)
                            l.append(temp)
                            l.append(l2[i+1])
                        else:
                            k=(l2[i].y-l2[i+1].y)/(l2[i].x-l2[i+1].x)
                            b=l2[i].y-k*l2[i].x
                            y=plb.y
                            if k!=0:
                                x=(y-b)/k
                            temp=point(x,y,0,0,0,0)
                            l.append(temp)
                            l.append(l2[i+1])
                    #都在外部,全部舍弃
                    else:
                        pass
        #初始化下裁剪后顶点坐标相对裁剪区域的位置
        for i in l:
            judgePositon(l)
        #输出下裁剪后顶点坐标
        print("bottomClip:")
        for i in l:
            print(i.x,i.y,i.pl,i.pt,i.pr,i.pb)

        #以绿线画裁剪后区域
        color=green
        glColor3fv(color)
        print('以绿线画被裁剪多边形')
        for i in range(0,len(l)):
            if(i==len(l)-1):
                glBegin(GL_LINES) #画线
                glVertex2f(l[i].x,l[i].y)
                glVertex2f(l[0].x,l[0].y)
                glEnd()
                glFlush()
            else:
                glBegin(GL_LINES) #画线
                glVertex2f(l[i].x,l[i].y)
                glVertex2f(l[i+1].x,l[i+1].y)
                glEnd()
                glFlush()

    elif (key==b'r'):#以红色画矩形裁剪窗口
        color=red
        glColor3fv(color)
        print('以红线画矩形裁剪窗口')
        glBegin(GL_LINES) #画线
        glVertex2f(l1[0].x,l1[0].y)
        glVertex2f(l1[0].x,l1[1].y)

        glVertex2f(l1[0].x,l1[1].y)
        glVertex2f(l1[1].x,l1[1].y)

        glVertex2f(l1[1].x,l1[1].y)
        glVertex2f(l1[1].x,l1[0].y)

        glVertex2f(l1[1].x,l1[0].y)
        glVertex2f(l1[0].x,l1[0].y)
        glEnd()
        glFlush()
    elif (key==b'b'):
        color=blue
        glColor3fv(color)
        print('以蓝线画被裁剪多边形')
        for i in range(2,len(l1)):
            if(i==len(l1)-1):
                glBegin(GL_LINES) #画线
                glVertex2f(l1[i].x,l1[i].y)
                glVertex2f(l1[2].x,l1[2].y)
                glEnd()
                glFlush()
            else:
                glBegin(GL_LINES) #画线
                glVertex2f(l1[i].x,l1[i].y)
                glVertex2f(l1[i+1].x,l1[i+1].y)
                glEnd()
                glFlush()

def mouse(button,state,x,y):
    #鼠标左键按下
    if button == GLUT_LEFT_BUTTON and state == GLUT_DOWN:
        glColor3fv(color)
        temp=point(x,y,0,0,0,0)
        translate(temp)
        l1.append(temp)
print('使用说明:')
print('请用鼠标点击确定矩形裁剪区域左下点与右下点坐标,按\'r\'键绘制裁剪区域')
print('请用鼠标点击确定被裁剪区域坐标,按\'b\'键绘制被裁剪区域')
print('按\'g\'键绘制被裁剪后区域')
print('按\'e\'键初始化界面')
print('按\'q\'键退出程序')

glutInit(sys.argv)
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGBA)
glutInitWindowSize(winx,winy)
glutInitWindowPosition(100,100)
winid=glutCreateWindow(b"main")    #建立窗口的ID返回到winid
glutDisplayFunc(display)
glutReshapeFunc(reshape)
glutKeyboardFunc(key)
glutMouseFunc(mouse)
glutMainLoop()
时间: 2024-11-02 12:08:05

矩形裁剪算法_pyopengl的相关文章

矩形裁剪算法_python3最终版

环境准备: Python版本是3.5.1.使用pip命令:pip install pyopengl 安装pyopengl模块 另外注意需要将opengl文件(打开文件链接,也可自行百度)复制到系统盘System32(32位系统)或SysWOW64(64位系统)目录下,不然可能或报错.我今天在学校实验室碰到了此问题,错误信息好像是glutInit函数不能使用之类的. 说明: 老师的要求是实现键盘输入和鼠标点击两种交互方式,没法子,只好封装一下函数,方便调用了. 代码: #encoding='utf

清华版CG 实验4 编码裁剪算法

1.实验目的: 了解二维图形裁剪的原理(点的裁剪.直线的裁剪.多边形的裁剪),利用VC+OpenGL实现直线的裁剪算法. 2.实验内容: (1) 理解直线裁剪的原理(Cohen-Surtherland算法.梁友栋算法) (2) 利用VC+OpenGL实现直线的编码裁剪算法,在屏幕上用一个封闭矩形裁剪任意一条直线. (3) 调试.编译.修改程序. (4) 尝试实现梁友栋裁剪算法. 3.实验原理: 编码裁剪算法中,为了快速判断一条直线段与矩形窗口的位置关系,采用了如图A.4所示的空间划分和编码方案.

Cohen Sutherland裁剪算法并使用OpenGL实践

还是其几天写的,这是最简单的一个直线裁剪算法了吧,它针对的是一个矩形和一条线段.并且还是边与坐标轴平行的矩形. 在实际应用上应该会经常用于屏幕对各种线段的裁剪吧.算法很简单效率也很高. 首先是算法的两种特例:平凡接受和平凡拒绝. (图片来自<计算机图形学(OpenGL)>第三版) 当线段的两个端点都在矩形内部,则平凡接受,不需要裁剪.如图中的AB.而当线段的两个端点都在某条边的外边时,平凡拒绝,也不需要裁剪.如图中的CD. 检测这两种情况的方法可以先形成两个端点的码字,如下: 那么可以得到如下

[计算机图形学 with OpenGL] Chapter8 习题8.12 NLN二维线段裁剪算法实现

Nicholl-Lee-Nicholl二维线段裁剪算法相对于Cohen-Sutherland和Liang-Barsky算法来说,在求交点之前进行了线段端点相对于几个区域的判断,可以确切的知道要求交点的边的信息. 此方法只在二维空间裁剪时使用,C-S和L-B裁剪方法则可应用到三维空间. 算法步骤: 1 先使用C-S裁剪算法的区域码判断方法,去除一部分在裁剪区域外面的线段.显示在完全在裁剪区域内的线段.其他不能判断的情况,采用NLN算法进行裁剪. 2 p1和p2若有一点在区域内,必要时交换端点以确保

Cyrus-Beck裁剪算法及OpenGL实践

恩..接着就是Cyrus-Beck算法.这个算法比之前的Cohen-Sutherland算法厉害,处理任意凸多边形对线段的裁剪.自然,这个算法也比Cohen-Sutherland算法复杂不少. 首先,是线段与多边形相交的情况: 我们把定义向量c = (C - A),而线段AC是射线A + ct的一部分.那么t取0和1就是线段AC.我们将射线与多边形的每条边求出相交时的t.取tin = max(0, tin),tout = max(tout, 1).最终会获得一个区间[tin,tout]就是经多边

CGA裁剪算法之Sutherland-Hodgman多边形裁剪算法

CGA裁剪算法之Sutherland-Hodgman多边形裁剪算法 Sutherland-Hodgman算法也叫逐边裁剪法,该算法是萨瑟兰德(I.E.Sutherland)和霍德曼(Hodgman)在1974年提出的. 这种算法采用了分割处理.逐边裁剪的方法.这一算法,适合任何凸多边形窗口对任何“凸或者凹,或者平面或者非平面”多边形的裁剪处理. 逐边逐次裁剪特点:逐边是分别用裁剪平面的边界来处理,且裁剪各个边界的处理顺序无关紧要.逐次是每次的裁剪边界对多边形的每条边处理是依次进行的,有顺序要求.

[图形学]Chapter 8.7.2 梁友栋-Barsky线段裁剪算法

这节简单介绍了梁友栋-Barsky裁剪算法的原理,只有结论并没有过程,看过http://blog.csdn.net/daisy__ben/article/details/51941608这篇文章后,大概有了新的认识. " 假设点P1P2W1W2的横坐标分别是x1,x2,w1,w2,线段P1P2与蓝色裁剪窗口W1W2(蓝色的线之间)的存在公共部分(可见部分)的充要条件是: max(min(x1,x2), min(w1,w2))≤ min(max(x1,x2), max(w1,w2)) 即所谓左端点

计算机图形学 Cohen-Sutherland直线段裁剪算法

作者 : 卿笃军 原文地址:http://blog.csdn.net/qingdujun/article/details/40822977 本文通过一个完整的实例演示Cohen-Sutherland直线段裁剪算法. 1)创建类CP2 头文件:P2.h // P2.h: interface for the CP2 class. // ////////////////////////////////////////////////////////////////////// #if !defined

Android 用Canvas画textview、bitmap、矩形(裁剪)、椭圆、线、点、弧

初始化对象 private Paint mPaint;//画笔 private int count;//点击次数 private Rect rect;//矩形 public CounstomView(Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); //初始化画笔 mPaint = new Paint(); rect = new Rect(); setOnClickListe