# proyecta 9_7
#
#  OJO QUE TRABAJA POR PASO CON EL COLOR DE LOS ELEMENTOS
#
# calcula las coordenadas de interseccion de un rayo  que  pasa por el punto de vista.
# contra un plano que pasa por un punto y es perpendicular a una direccion dada 

# opera con numpy
#incluye rotacion de los planos de proyeccion
import os, pickle, shelve, sys
import Tkinter
from Tkinter import *
from math import *
import numpy 
from numpy.linalg import inv
import ast


# defino variables globales
flag=0
w_max=700.0     # ancho de ventana
h_max=600.0     # alto de ventana

x_min=-1500.0    #rango de las x
x_max=1500.0
y_min=-1500.0    #rango de las y
y_max=1500.0
tipo_proyec="c"   # "c" o "p"
largo_eje=120
distancia=200
btn_h=1          #alto del boton
btn_w=8 
tamano=0        #tamano del punto

##################################3
tx=0.0
ty=0.0
tz=0.0
roll=0.0
pitch=0.0
yaw=0.0
#################################


recta=0
plano=0
proyectante=0
interseccion=0
auxiliar=0


class cpunto3D:
    def __init__(self, x, y, z,idnumero):
        self.x=x                  # Coordenadas del punto en unidades de pantalla
        self.y=y              # Coordenadas del punto en unidades de pantalla 3D
        self.z=z                    # Coordenadas del punto en unidades de geometria
        self.idnumero=idnumero
class cpunto2D:
    def __init__(self, x, y):
        self.x=x                  # Coordenadas del punto en unidades de pantalla
        self.y=y              # Coordenadas del punto en unidades de pantalla 2D
        #self.idpunto=idpunto    #numero de identificacion
        
class cborde:
    def __init__(self, b, e,color,ancho):
        self.b=b                  # Coordenadas del punto en unidades de pantalla
        self.e=e              # Coordenadas del punto en unidades de pantalla 2D
        self.color=color
        self.ancho=ancho


puntos=[]           #es la lista con los puntos del sistema de coordenadas que dibujo
vertices=[]         #es la lista con las coordenadas en 3D de los vertices del objeto
vert2D=[]           #es la lista con las coordenadas de dibujo en 2d
arista=[]           # es la lista de las aristas
vert1=[]            # es la lista de los vertices rotados



Q=numpy.zeros([4], )
# t es la matriz de rotacion
t=numpy.zeros([4,4], )


# transforma las coordenadas de geometria 
# al dominio w_max (eje horizontal de pantalla)
# al dominio h_max (eje vertical de pantalla)
# al poner por ejemplo x_min=x_min estoy usando variable global para pasar
# como argumento
def geom_to_pant(a2,a3,x_min=x_min,x_max=x_max,w_max=w_max,y_min=y_min,y_max=y_max,h_max=h_max):

        d1=a2+w_max/2
        d2=-a3+h_max/2
        return d1,d2

def lee_archivo():
    global base
    buff=[]
    if len(sys.argv)>1: #se corre el programa con un argumento
        archivo=sys.argv[1] # recupera el nombre del archivo de la linea de comando

        f=open(archivo,'r')
        buff=f.readlines() 
        f.close

        for i in range(len(buff)):
            bb=buff[i]
    
        j=0                        
        for i in range(len(buff)):
            bb=buff[i]
            bb1=bb.find("(")
            bb2=bb.find(")")
            bb3=bb.find("{")
            bb4=bb.find("}")
        
            if bb[0]=="P":
                indice=int(bb[bb1+1:bb2])
                contenido=bb[bb3+1:bb4].split(",")
                j=j+1
                idnumero= j
                z= float(contenido[2])
                y= float(contenido[1])
                x= float(contenido[0])
                vertices.append(cpunto3D(x,y,z,idnumero))
                #print "P",indice,vertices[len(vertices)-1].x,vertices[len(vertices)-1].y,vertices[len(vertices)-1].z,"id",vertices[len(vertices)-1].idnumero
            elif bb[0]=="L":     
                indice=int(bb[bb1+1:bb2])
                #print "indice ", indice, len(arista)
                contenido=bb[bb3+1:bb4].split(",")
                if archivo.split(".")[1]=="geox":
                    
                    b=int(contenido[0])
                    e=int(contenido[1])
                    colo=str(contenido[2])
                    ancho=str(contenido[3])
                    arista.append(cborde(b,e,colo ,ancho))
                else:
                    arista.append(cborde(int(contenido[0]),int(contenido[1]),"black",1))
            else:
                print "otrascosa","-"+bb[0]+"-"
    # se definen los puntos para el sistema de coordenadas
    base=len(vertices)
    vertices.append(cpunto3D(0.0,0.0,0.0,base+1))
    #extremos de ejes
    vertices.append(cpunto3D(largo_eje,0.0,0.0,base+2)) # eje x
    vertices.append(cpunto3D(0.0,largo_eje,0.1,base+3)) #eje y
    vertices.append(cpunto3D(0.1,largo_eje,0.0,base+4)) #eje y duplicado
    vertices.append(cpunto3D(0.0,0.0,largo_eje,base+5))   #eje z
    #extremos de plano
    vertices.append(cpunto3D(largo_eje,largo_eje,0.0,base+6)) #vertice plano xy
    vertices.append(cpunto3D(0.0,largo_eje,largo_eje,base+7))  #vertice plano yz
    vertices.append(cpunto3D(largo_eje,0.0,largo_eje,base+8))   #vertice plano xz

    color_planos="gray"
    ancho_linea_planos=2
    base=base+1
 
    
    arista.append(cborde(base,base+1,color_planos,ancho_linea_planos))   # eje x
    arista.append(cborde(base,base+2,color_planos,ancho_linea_planos))   #eje y
    arista.append(cborde(base,base+3,color_planos,ancho_linea_planos))   #eje y dupliacdo
    arista.append(cborde(base,base+4,color_planos,ancho_linea_planos))   # eje z
    arista.append(cborde(base+1,base+5,color_planos,ancho_linea_planos))
    arista.append(cborde(base+5,base+3,color_planos,ancho_linea_planos))
    arista.append(cborde(base+4,base+6,color_planos,ancho_linea_planos))
    arista.append(cborde(base+6,base+2,color_planos,ancho_linea_planos))
    arista.append(cborde(base+1,base+7,color_planos,ancho_linea_planos))
    arista.append(cborde(base+7,base+4,color_planos,ancho_linea_planos))
    
    #for i in range(len(vertices)):
       # print "vertice",i,vertices[i].x,vertices[i].y,vertices[i].z,vertices[i].idnumero
        
        
    #for i in range(len(arista)):
        #print "arista",i, arista[i].b,arista[i].e,arista[i].color,arista[i].ancho
        
    #define los puntos de vista
    puntos.append(cpunto3D(100.0,100.0,100.0,1))  #primer punto de la recta que orienta el plano y es el punto de vista
    puntos.append(cpunto3D(1.0,1.0,1.0,1))        #segundo punto de la recta que orienta el plano 
    
    # recorro las aristas buscando los extremos apoyados en el eje y
    
    parte_nudo()
    
    #for i in range(len(vertices)):
        #print "vertice",i,vertices[i].x,vertices[i].y,vertices[i].z
        
    #for i in range(len(arista)):
        #print "arista",i, arista[i].b,arista[i].e
           
    return


def cohensutherland(left, top, right, bottom, x1, y1, x2, y2):
    # rutina de cliping
    LEFT, RIGHT, LOWER, UPPER = 1, 2, 4, 8
    k1 = k2 = 0
    def _getclip(xa, ya):
        p = 0
        if xa < left:
            p = LEFT
        elif xa > right:
            p = RIGHT
        if ya < bottom:
            p |= LOWER
        elif ya > top:
            p |= UPPER
        return p

    k1 = _getclip(x1, y1)
    k2 = _getclip(x2, y2)
 
    while (k1 | k2) != 0:
        if (k1 & k2) != 0:
             return x1,y1,x2,y2
        opt = k1 or k2
 
        if opt & UPPER:
            x = x1 + (x2 - x1) * (1.0 * (top - y1)) / (y2 - y1)
            y = top
        elif opt & LOWER:
            x = x1 + (x2 - x1) * (1.0 * (bottom - y1)) / (y2 - y1)
            y = bottom
        elif opt & RIGHT:
            y = y1 + (y2 - y1) * (1.0 * (right - x1)) / (x2 - x1)
            x = right
        else:
            y = y1 + (y2 - y1) * (1.0 * (left - x1)) / (x2 - x1)
            x = left
        if opt == k1:
            x1, y1 = int(x), int(y)
            k1 = _getclip(x1, y1)
        else:
            x2, y2 = int(x), int(y)
            k2 = _getclip(x2, y2)
    
    return x1, y1, x2, y2




def proy(p,v,distancia):
#   rutina de proyeccion de punto y trasnformacion de sistema de 3D a 2D    
    #valores auxiliares

    a=p[0].x-p[1].x
    b=p[0].y-p[1].y
    c=p[0].z-p[1].z

    alfa=p[0].x-v.x
    beta=p[0].y-v.y
    gama=p[0].z-v.z
    
    p4x=p[0].x-distancia*a/(sqrt(a**2+b**2+c**2))
    p4y=p[0].y-distancia*b/(sqrt(a**2+b**2+c**2))
    p4z=p[0].z-distancia*c/(sqrt(a**2+b**2+c**2))

#coordenadas del punto del plano perpendicular
# el plano tiene la forma de a.x+b.y+c.z+d=0
# donde a,b,c son las componentes del vector normal al plano
# y (x4,y4,z4) son las coordenadas de un punto del plano
#luego d=-(a.x+b.y+c.z)

    d=-(a*p4x+b*p4y+c*p4z)


# y la ecuacion del plano sera de la forma a.x+b.y+c.z-a.x4-b.y4-c.z4=0
#haciendo lo mismo con la recta que une el punto de vista (x0,y0,z0) y el punto proyectado (x2,y2,z2)

    if tipo_proyec=="c":
        lam=(a*(p4x-p[0].x)+b*(p4y-p[0].y)+c*(p4z-p[0].z))/(a*alfa+b*beta+c*gama)
        p5x=p[0].x+lam*alfa
        p5y=p[0].y+lam*beta
        p5z=p[0].z+lam*gama
    else:
        lam=(a*(p4x-v.x)+b*(p4y-v.y)+c*(p4z-v.z))/(a*a+b*b+c*c)
        p5x=v.x+lam*a
        p5y=v.y+lam*b
        p5z=v.z+lam*c

#luego el punto proyectado en D3 sera x5,y5,z5

    #p5x=p[0].x+lam*alfa
    #p5y=p[0].y+lam*beta
    #p5z=p[0].z+lam*gama


    t=(a*(p4x-p[0].x)+b*(p4y-p[0].y)+c*(p4z-p[0].z))/(a**2+b**2+c**2)

    p3x=p[0].x+t*a
    p3y=p[0].y+t*b
    p3z=p[0].z+t*c
  #  print "punto de origen del sistema local"


# Matriz de transformacion
#   1       0       0       0
#   Xo      Ux      Vx      Wx
#   Yo      Uy      Vy      Wy
#   Zo      Uz      Vz      Wz

#  Xo,Yo,Zo, coordenadas del origen del sistema local expresado en coordenadas globales
#   Ux,Uy,Uz versor de uno de los ejes del sist. local expresado en coordenadas globales
#   Vx,Vy,Vz versor de uno de los ejes del sist. local expresado en coordenadas globales
#   Wx,Wy,Wz versor de uno de los ejes del sist. local expresado en coordenadas globales

    vA=a/(sqrt(a**2+b**2+c**2))
    vB=b/(sqrt(a**2+b**2+c**2))
    vC=c/(sqrt(a**2+b**2+c**2))

    M=numpy.array([[    1,     0,       0,       0],
                    [    p3x,    vA,      vB,      vA*vC],
                    [    p3y,    vB,     -vA,      vB*vC],
                    [    p3z,    vC,       0,   -vA**2-vB**2]])            
          

#   1       X       Y   Z
# Coordenadas del punto en el sistema Global

    Pmat=numpy.array([1,     p5x,       p5y,       p5z])
 
# multiplico por -1 porque la terna obtenida por los productos vectoriales 
# me queda orientada al reves

    Q=numpy.dot(numpy.linalg.inv(M),Pmat)
#    a0=round(Q[0],0)
#    a1=round(Q[1],0)
    x=round(Q[2],0)*-1 # multiplico por -1 porque la terna obtenida por los productos vectoriales 
    y=round(Q[3],0)*-1 # me queda orientada al reves
    #print "proyecta",x,y

    return x,y
    

def matriz_rot(roll,pitch,yaw,tx,ty,tz):
#rutina de rotacion    
    t[0,0]=cos(yaw)*cos(roll)+sin(yaw)*sin(pitch)*sin(roll)
    t[0,1]=cos(pitch)*sin(roll)
    t[0,2]=-sin(yaw)*cos(roll)+cos(yaw)*sin(pitch)*sin(roll)
    t[0,3]=-(tx*t[0][0]+ty*t[0][1]+tz*t[0][2])
    t[0,3]=-tx
    t[1,0]=-cos(yaw)*sin(roll)+sin(yaw)*sin(pitch)*cos(roll)
    t[1,1]=cos(pitch)*cos(roll)
    t[1,2]=sin(yaw)*sin(roll)+cos(yaw)*sin(pitch)*cos(roll)
    t[1,3]=-(tx*t[1][0]+ty*t[1][1]+tz*t[1][2])
    t[1,3]=-ty
    t[2,0]=sin(yaw)*cos(pitch)
    t[2,1]=-sin(pitch)
    t[2,2]=cos(yaw)*cos(pitch)
    t[2,3]=-(tx*t[2][0]+ty*t[2][1]+tz*t[2][2])
    t[2,3]=-tz
    t[3,0]=0
    t[3,1]=0
    t[3,2]=0
    t[3,3]=1
    return


def saca_id(a):
    #busca el valor del id del vertice y devuelve su posicion en el vector
    x=0
    for i in range(len(vertices)):
        #print "--",a,i,vertices[i].idnumero
        if vertices[i].idnumero==a:
            x=i 

    return  x
    
def dibuja():
    global h_max, w_max,roll,pitch,yaw,t
    
    canvas.delete(Tkinter.ALL)
    vert2D=[]
    #   lleno ver1 con ceros para poder despues cambiarlos
    for i in range(len(vertices)):
        vert1.append(cpunto3D(0,0,0,0))
    # lleno veret1 con las coordenadas de los vertices pero los afecto por las rotaciones
    # los que no son ejes
    roll1=0.0
    pitch1=0.0
    yaw1=0.0
    
    for i in range(len(vertices)):
       
        if vertices[i].x==0.0:
            roll1=roll
        else:
            roll1=0.0

        if vertices[i].z==0:
            pitch1=pitch
        else:
            pitch1=0.0

        matriz_rot(roll1,pitch1,yaw1,tx,ty,tz)
        vert1[i].x=vertices[i].x*t[0,0]+vertices[i].y*t[0,1]+vertices[i].z*t[0,2]
        vert1[i].y=vertices[i].x*t[1,0]+vertices[i].y*t[1,1]+vertices[i].z*t[1,2]
        vert1[i].z=vertices[i].x*t[2,0]+vertices[i].y*t[2,1]+vertices[i].z*t[2,2]
    # ahora proyecto todos los puntos a 2D
    for i in range(len(vertices)):
        x,y=proy(puntos,vert1[i],distancia)
        dumx,dumy=geom_to_pant(x,y)
#        print "dumx dumy",i,dumx,dumy
        vert2D.append(cpunto2D(dumx,dumy))
     
    
# trihedro

    # dibuja puntos
    for i in range(len(vertices)):
        if i>-1 and vertices[i].idnumero<base:  # no dibujo los puntos del trihedro (base es la variable que traigo comoo global de la lectura)
            
            canvas.create_oval(vert2D[i].x-tamano,vert2D[i].y-tamano,vert2D[i].x+tamano,vert2D[i].y+tamano,fill="red")
            print "vertice",i
            # descomentar la siguiente para identificar los puntos
            #if i>=1 and i<=10 :
                #canvas.create_text(vert2D[i].x-10,vert2D[i].y-10,text=vertices[i].idnumero,fill="black")
    # dibuja figura 

    
    for i in range(len(arista)):
        
        p_inicio=saca_id(arista[i].b)
        p_fin=saca_id(arista[i].e)
       # or (proyectante==1 and arista[i].color=="green") or (interseccion==1 and arista[i].color=="red") or (arista[i].color="grey")
        if  ((recta==1 and arista[i].color=="blue") or (plano==1 and arista[i].color=="black")or (proyectante==1 and arista[i].color=="green") or (interseccion==1 and arista[i].color=="red")or (auxiliar==1 and arista[i].color=="white") or (arista[i].color=="gray")):
            if roll==0.0 and pitch==0.0:
                canvas.create_line(cohensutherland(0, h_max, w_max, 0,vert2D[p_inicio].x,vert2D[p_inicio].y,vert2D[p_fin].x,vert2D[p_fin].y),fill=arista[i].color,width=arista[i].ancho)
            else:
                #if vertices[p_inicio].x ==vertices[p_fin].x or vertices[p_inicio].y ==vertices[p_fin].y or vertices[p_inicio].z ==vertices[p_fin].z:     
                if (vertices[p_inicio].x ==vertices[p_fin].x) and vertices[p_inicio].x==0 or (vertices[p_inicio].y ==vertices[p_fin].y) and vertices[p_inicio].y==0 or (vertices[p_inicio].z ==vertices[p_fin].z) and vertices[p_inicio].z==0:     
                    canvas.create_line(cohensutherland(0, h_max, w_max, 0,vert2D[p_inicio].x,vert2D[p_inicio].y,vert2D[p_fin].x,vert2D[p_fin].y),fill=arista[i].color,width=arista[i].ancho)
    return


# inserta un texto en un box
def set_text(text):
    e.delete(0,END)
    e.insert(0,text)
    return

def per_rec():
    global tipo_proyec
    
    if tipo_proyec=="c": 
        tipo_proyec="p"
    else:
        tipo_proyec="c"        
    dibuja()
    
    
def b_reset():
    global puntos
    puntos[0].x=200.0
    puntos[0].y=200.0
    puntos[0].z=200.0
    distancia=500
    dibuja()
    
def b_aplana():
    global puntos
    puntos[0].x=0.0
    puntos[0].y=1000.0
    puntos[0].z=0.0
    distancia=1900.
    dibuja()
    
def regla_tx(x):
    global puntos
    puntos[0].x = float(x)
    dibuja()

def regla_ty(x):
    global puntos
    puntos[0].y = float(x)
    dibuja()

def regla_tz(x):
    global puntos
    puntos[0].z = float(x)
    dibuja()
    
def regla_distancia(x):
    global distancia
    distancia = float(x)
    dibuja()

def regla_punto(x):
    global tamano
    tamano = float(x)
    dibuja()
    
def regla_pitch(x):
    global pitch
    pitch = float(x)
    dibuja()

def regla_roll(x):
    global roll
    roll = float(x)
    dibuja()

def parte_nudo():

    for i in range(len(arista)):
        if i>=-1:
            nudo_b= saca_id(arista[i].b)
            nudo_e= saca_id(arista[i].e)
            #print i,nudo_b, vertices[nudo_b].x,vertices[nudo_b].y,vertices[nudo_b].z,"---",nudo_e, vertices[nudo_e].x,vertices[nudo_e].y,vertices[nudo_e].z
            if vertices[nudo_b].x ==0.0 and vertices[nudo_e].x==0.0: #esta apoyado en yz?
                #print"modifique arista",i,"del ",nudo_b,"a "
                if vertices[nudo_b].z==0.0 :
                    ultimo=len(vertices)+1
                    vertices.append(cpunto3D(vertices[nudo_b].x,vertices[nudo_b].y,vertices[nudo_b].z+0.1,ultimo))
                    arista[i].b=ultimo
                    #print"1 modifique arista",i,"del ",nudo_b,"a ",ultimo,len(vertices)
                    
           
                if vertices[nudo_e].z==0.0 :
                    ultimo=len(vertices)+1
                    vertices.append(cpunto3D(vertices[nudo_e].x,vertices[nudo_e].y,vertices[nudo_e].z+0.1,ultimo))
                    arista[i].e=ultimo
                    #print"2 modifique arista",i,"del ",nudo_e,"a ",ultimo,len(vertices)
           
                
            if vertices[nudo_b].z ==0.0 and vertices[nudo_e].z==0.0: #esta apoyado en xy?
                if vertices[nudo_b].x==0.0 :
                    ultimo=len(vertices)+1
                    vertices.append(cpunto3D(vertices[nudo_b].x+0.1,vertices[nudo_b].y,vertices[nudo_b].z,ultimo))
                    arista[i].b=ultimo
                    #print"3 modifique arista",i,"del ",nudo_b,"a ",ultimo,len(vertices)
           
                if vertices[nudo_e].x==0.0 :
                    ultimo=len(vertices)+1
                    vertices.append(cpunto3D(vertices[nudo_e].x+0.1,vertices[nudo_e].y,vertices[nudo_e].z,ultimo))
                    arista[i].e=ultimo
                    #print"4 modifique arista",i,"del ",nudo_e,"a ",ultimo,len(vertices)

def agrega_punto():
    xlocal=float(mov_x_e.get())
    ylocal=float(mov_y_e.get())
    zlocal=float(mov_z_e.get())
    print xlocal,ylocal,zlocal,
    ultimo=len(vertices)
    vertices.append(cpunto3D(xlocal,ylocal,zlocal,ultimo+1)) # punto en 3d
    vertices.append(cpunto3D(xlocal,ylocal,0.0,ultimo+2)) # proyeccion horixontal
    vertices.append(cpunto3D(xlocal,0.0,zlocal,ultimo+3)) # proyeccion vertical
    vertices.append(cpunto3D(0.0,ylocal,zlocal,ultimo+4)) # proyec lateral
    vertices.append(cpunto3D(xlocal,0,0.0,ultimo+5)) # proyeccion sobre x
    vertices.append(cpunto3D(0.0,ylocal,0.0,ultimo+6)) # proyeccion sobre y
    vertices.append(cpunto3D(0.0,0.0,zlocal,ultimo+7)) # proyec sobre z
    
    
    #arista.append(cborde(base,base+1,color_planos,ancho_linea_planos))  
    arista.append(cborde(ultimo+1,ultimo+2,"white",1))
    arista.append(cborde(ultimo+1,ultimo+3,"white",1))
    arista.append(cborde(ultimo+1,ultimo+4,"white",1))
    
    arista.append(cborde(ultimo+2,ultimo+5,"white",1))
    arista.append(cborde(ultimo+3,ultimo+5,"white",1))
    arista.append(cborde(ultimo+2,ultimo+6,"white",1))
    arista.append(cborde(ultimo+4,ultimo+6,"white",1))
    arista.append(cborde(ultimo+3,ultimo+7,"white",1))
    arista.append(cborde(ultimo+4,ultimo+7,"white",1))
    # recorro las aristas buscando los extremos apoyados en el eje y
    parte_nudo()
    
    dibuja()
    return
    
def c_recta():
    global recta
    recta=chk_recta.get()
    dibuja()
    return  

def c_plano():
    global plano
    plano=chk_plano.get()
    dibuja()
    return  
    
def c_proyectante():
    global proyectante
    proyectante=chk_proyectante.get()
    dibuja()
    return  

def c_interseccion():
    global interseccion
    interseccion=chk_interseccion.get()
    dibuja()
    return 
    
def c_auxiliar():
    global auxiliar
    auxiliar=chk_auxiliar.get()
    dibuja()
    return 

def salir():
    exit()
    
root = Tkinter.Tk()
root.columnconfigure(0, weight=1)
root.rowconfigure(0, weight=1)
root.title("++++++")
canvas = Tkinter.Canvas(root,width=w_max, height=h_max,bg="skyblue")


chk_recta=IntVar()
chk_plano=IntVar()
chk_proyectante=IntVar()
chk_interseccion=IntVar()
chk_auxiliar=IntVar()


#pantalla de movimiento
wn=Tkinter.Toplevel()
wn.title("Movimi")
wn.geometry("300x350+1050+50")

#pantalla de objetos
wo=Tkinter.Toplevel()
wo.title("Objetos")
wo.geometry("250x150+750+500")

#append de nodo
wo.button_move =Tkinter.Button(wo, text="ADD", fg="black",bg="lavender", command=agrega_punto, height=btn_h, width=btn_w)
wo.button_move.grid(row=0,column=8,sticky=Tkinter.W)
lab1=Tkinter.Label(wo,text="XMOVE")
lab1.grid(row=1,column=7,sticky=Tkinter.E)
mov_x_e=Tkinter.Entry(wo,width=10)
mov_x_e.grid(row=1,column=8,sticky=Tkinter.W)
lab2=Tkinter.Label(wo,text="YMOVE")
lab2.grid(row=2,column=7,sticky=Tkinter.E)
mov_y_e=Tkinter.Entry(wo,width=10)
mov_y_e.grid(row=2,column=8,sticky=Tkinter.W)
lab3=Tkinter.Label(wo,text="ZMOVE")
lab3.grid(row=3,column=7,sticky=Tkinter.E)
mov_z_e=Tkinter.Entry(wo,width=10)
mov_z_e.grid(row=3,column=8,sticky=Tkinter.W)



#movimiento de punto de vista

wn.button_vista = Tkinter.Button(wn, text="Persp", command= per_rec)
wn.button_vista.grid(row=6,column=9)

wn.button_vista = Tkinter.Button(wn, text="Aplan", command= b_aplana)
wn.button_vista.grid(row=7,column=9)

wn.button_reset = Tkinter.Button(wn, text="Reset", command= b_reset)
wn.button_reset.grid(row=8,column=9)

wn.button_salir = Tkinter.Button(wn, text="Salir", command= salir,bg="yellow")
wn.button_salir.grid(row=9,column=9)




lab1=Tkinter.Label(wn,text="XMOVE")
lab1.grid(row=1,column=7,sticky=Tkinter.E)
wn_x=Tkinter.Scale(wn,orient="horizontal",command=regla_tx,from_=-1000.0,to=1000.0,resolution=20.0)
wn_x.grid(row=1,column=8)
if flag==0 :
    wn_x.set(200)

lab2=Tkinter.Label(wn,text="YMOVE")
lab2.grid(row=2,column=7,sticky=Tkinter.E)
wn_y=Tkinter.Scale(wn,orient="horizontal",command=regla_ty,from_=-1000.0,to=1000.0,resolution=20.0)
wn_y.grid(row=2,column=8)
if flag==0 :
    wn_y.set(200)

lab3=Tkinter.Label(wn,text="ZMOVE")
lab3.grid(row=3,column=7,sticky=Tkinter.E)
wn_z=Tkinter.Scale(wn,orient="horizontal",command=regla_tz,from_=-1000.0,to=1000.0,resolution=20.0)
wn_z.grid(row=3,column=8)
if flag==0 :
    wn_z.set(200)

lab4=Tkinter.Label(wn,text="DISTAN")
lab4.grid(row=4,column=7,sticky=Tkinter.E)
wn_d=Tkinter.Scale(wn,orient="horizontal",command=regla_distancia,from_=50.0,to=2000.0,resolution=20.0)
wn_d.grid(row=4,column=8)
if flag==0 :
    wn_d.set(500)

# deslizante del tamano de punto

lab5=Tkinter.Label(wn,text="PUNTO")
lab5.grid(row=5,column=7,sticky=Tkinter.E)
wn_t=Tkinter.Scale(wn,orient="horizontal",command=regla_punto,from_=0.0,to=10.0,resolution=1.0)
wn_t.grid(row=5,column=8)
if flag==0 :
    wn_t.set(tamano)

#movimientos de planos de proyeccion

lab1=Tkinter.Label(wn,text="P.Lateral")
lab1.grid(row=7,column=7,sticky=Tkinter.E)
wn_r=Tkinter.Scale(wn,orient="horizontal",command=regla_roll,from_=0.0,to=-1.57,resolution=0.1)
wn_r.grid(row=7,column=8)
if flag==0 :
    wn_r.set(0)


lab2=Tkinter.Label(wn,text="P.Horiz")
lab2.grid(row=8,column=7,sticky=Tkinter.E)
wn_p=Tkinter.Scale(wn,orient="horizontal",command=regla_pitch,from_=0.0,to=1.57,resolution=0.1)
wn_p.grid(row=8,column=8)
if flag==0 :
    wn_p.set(0)


# checkbox de objetos a dibujar

wn_c_recta=Tkinter.Checkbutton(wn,text="recta",variable=chk_recta, onvalue=1, offvalue=0, command=c_recta)
wn_c_recta.grid(row=1,column=10,sticky=Tkinter.W)

wn_c_recta=Tkinter.Checkbutton(wn,text="plano",variable=chk_plano, onvalue=1, offvalue=0, command=c_plano)
wn_c_recta.grid(row=2,column=10,sticky=Tkinter.W)

wn_c_proyectante=Tkinter.Checkbutton(wn,text="proyec",variable=chk_proyectante, onvalue=1, offvalue=0, command=c_proyectante)
wn_c_proyectante.grid(row=3,column=10,sticky=Tkinter.W)

wn_c_interseccion=Tkinter.Checkbutton(wn,text="interse",variable=chk_interseccion, onvalue=1, offvalue=0, command=c_interseccion)
wn_c_interseccion.grid(row=4,column=10,sticky=Tkinter.W)

wn_c_auxiliar=Tkinter.Checkbutton(wn,text="aux",variable=chk_auxiliar, onvalue=1, offvalue=0, command=c_auxiliar)
wn_c_auxiliar.grid(row=5,column=10,sticky=Tkinter.W)


flag=1

lee_archivo()

#menu = Menu(root)
#root.config(menu=menu)
#filemenu = Menu(menu)
#menu.add_cascade(label="File    ", menu=filemenu)
#filemenu.add_command(label="Retrv", command=cambia_modo)
#filemenu.add_separator()
#filemenu.add_separator()
#filemenu.add_command(label="Exit", command=root.quit)

#opermenu = Menu(menu)
#menu.add_cascade(label="Oper    ", menu=opermenu)
#opermenu.add_command(label="Linea", command=modo_linea)
#opermenu.add_command(label="Arco", command=modo_arco)

canvas.grid(column=0, row=0,columnspan=4,rowspan=4) #, sticky=(N, W, E, S))
#canvas.bind("<Button-1>", addline)
#canvas.bind("<Button-2>", deleteline)
#canvas.bind("<Motion>", navega)
#canvas.bind("<Button-3>", deleteline)
#can_id0=canvas.create_line((0, 0, 0, 0))

dibuja()



#can_id=canvas.create_arc(50,50, 200,200, style="arc",start=180,extent=90)

root.mainloop()