Playing with Tkinter (run this)

[kudos]

There is alot of GUI packages for Python, but as far as I know the only one that "comes with python" is Tkinter. Here is a toy program that draws a funny shape

# basis for this stuff was found at this guys website : http://matt.wandel.ca/
#[e-mail]
 
from Tkinter import *
import math 
 
root = Tk()
w = Canvas(root, width=300, height=300)
theta = 0.015
sx = 358.690012296
sy = 452.337492999
w.create_rectangle(0,0,300,300,fill="#000000")
while(theta<4*3.1415):
 xt = math.sin(theta * 10) * 270 + 300 
 yt = math.cos(theta * 9.5) * 270 + 300 
 nthet = xt / 30 + yt / 30 
 yp = yt + math.sin(nthet) * 20
 xp = xt + math.cos(nthet) * 20 
 w.create_line(sx/2,sy/2,xp/2,yp/2,fill="#ffffff",width=2)
 sx = xp
 sy = yp
 theta+=0.004
w.pack()
root.mainloop()
 

[bvdet]

That's really neat, kudos. Here's my first attempt at a script using Tkinter, following your example. It is a 2D point inside/outside polygon test where the point to test is selected randomly. The polygon is drawn upside down, but that's OK with me for this example.

import random
from Tkinter import *
 
class Point(object):
 
    def __init__(self, x=0.0, y=0.0):
        self.x = float(x)
        self.y = float(y)
 
    def __add__(self, other):
        return Point(self.x+other.x, self.y+other.y)
 
    def __sub__(self, other):
        return Point(self.x-other.x, self.y-other.y)
 
    def __mul__(self, f):
        return Point(self.x*f, self.y*f)
 
    def __div__(self, f):
        return Point(self.x/f, self.y/f)
 
    def ray(self, limit):
        return self, Point(limit, self.y)
 
    def inters(self, v1, v2):
        self.limit = max(v1.x, v2.x)+1
        P1, P2 = self.ray(limit)
        P3, P4 = v1, v2
        num_a = (P4.x-P3.x)*(P1.y-P3.y) - (P4.y-P3.y)*(P1.x-P3.x)
        num_b = (P2.x-P1.x)*(P1.y-P3.y) - (P2.y-P1.y)*(P1.x-P3.x)
        den = (P4.y-P3.y)*(P2.x-P1.x) - (P4.x-P3.x)*(P2.y-P1.y)
        self.ua = num_a/den
        self.ub = num_b/den
        x = P1.x + self.ua*(P2.x-P1.x)
        y = P1.y + self.ua*(P2.y-P1.y)
        self.px = Point(x,y)
        # print self.ua, self.ub
        if (0 <= self.ua <= 1) and (0 <= self.ub <= 1):
            return True
        return False
 
    def __iter__(self):
        for a in [self.x, self.y]:
            yield a
 
    def __str__(self):
        return 'Point(%0.4f, %0.4f)' % (self.x,self.y)
 
    def __repr__(self):
        return 'Point(%0.4f, %0.4f)' % (self.x,self.y)
 
epsilon = 0.00001
 
def common_vertex(pt,vertices):
    for v in vertices:
        if (abs(pt.x-v.x) < epsilon) and (abs(pt.y-v.y) < epsilon):
            return True
    return False
 
def inside_polygon(pt, polygon):
    # Consider pt is inside if on a vertex 
    if common_vertex(pt,polygon):
        print "The point lies on a polygon vertex."
        return True
    count = 0
    # check each line segment between vertices
    # 5 unique vertices represent a 5 sided polygon
    for i in range(len(polygon)-1):
        if pt.inters(polygon[i], polygon[i+1]):
            count += 1
            #if pt.ub in (0, 1):
                #print "The ray intersects at a vertex."
    # check line segment from last vertex to first vertex      
    if pt.inters(polygon[-1], polygon[0]):
        count += 1
        #if pt.ub in (0, 1):
            #print "The ray intersects at a vertex."
    # print count
    if count%2:
        #print "Point is INSIDE"
        return True
    else:
        #print "Point is OUTSIDE"
        return False
 
limit = 151    
 
pt1 = Point(random.choice(range(0,limit)), random.choice(range(0,limit)))
print pt1
polygon = [Point(122,122),
           Point(140,20),
           Point(100,34),
           Point(30,5),
           Point(19,90)]
 
print inside_polygon(pt1, polygon)
 
root = Tk()
w = Canvas(root, width=limit+10, height=limit+10)
w.create_rectangle(0,0,160,160,fill="#000000")
for i in range(len(polygon)-1):
    w.create_line(polygon[i].x, polygon[i].y, polygon[i+1].x, polygon[i+1].y,fill="#ffffff",width=1)
w.create_line(polygon[-1].x, polygon[-1].y, polygon[0].x, polygon[0].y,fill="#ffffff",width=1)
w.create_line(pt1.x, pt1.y, pt1.ray(limit+10)[1].x, pt1.ray(limit+10)[1].y,fill="#ffffff",width=1)
w.create_line(pt1.x, pt1.y-2, pt1.x, pt1.y+2,fill="#ffffff",width=1)
w.pack()
root.mainloop()