cleaner code

[imago.git] / gridf.py

diff --git a/gridf.py b/gridf.py
index 0955d7e..d39bdd5 100644 (file)
--- a/gridf.py
+++ b/gridf.py
@@ -1,9 +1,11 @@
+"""Imago grid-fitting module"""
+
 import multiprocessing
 
 import Image, ImageDraw, ImageFilter
 
-from geometry import V
-from manual import lines as g_grid, l2ad, intersection, line as g_line
+from geometry import V, projection
+from manual import lines as g_grid, l2ad
 from intrsc import intersections_from_angl_dist
 from linef import line_from_angl_dist
 import pcf
@@ -19,24 +21,21 @@ class MyGaussianBlur(ImageFilter.Filter):
     def filter(self, image):
         return image.gaussian_blur(self.radius)
 
-def projection(point, line, vector):
-    return V(*intersection(g_line(point, point + vector.normal), g_line(*line)))
-
 def job_br1(args):
     X, Y, im_l, a, b, c, d, s, v1, v2, k, hough, size = args
     return [(distance(im_l, 
-                     get_grid(a + X[y] * s * v1, 
-                              b + Y[y] * s * v1, 
-                              c, d, hough, size),
-                     size), a + X[y] * s * v1, b + Y[y] * s * v1) for y in range(2 *k)]
+             get_grid(a + X[y] * s * v1, 
+                      b + Y[y] * s * v1, 
+                      c, d, hough, size),
+             size), a + X[y] * s * v1, b + Y[y] * s * v1) for y in range(2 *k)]
 
 def job_br2(args):
     X, Y, im_l, a, b, c, d, s, v1, v2, k, hough, size = args
     return [(distance(im_l, 
-                     get_grid(a, b, c + X[y] * s * v2, 
-                              d + Y[y] * s * v2, 
-                              hough, size),
-                     size), c + X[y] * s * v2, d + Y[y] * s * v2) for y in range(2 *k)]
+             get_grid(a, b, c + X[y] * s * v2, 
+                      d + Y[y] * s * v2, 
+                      hough, size),
+             size), c + X[y] * s * v2, d + Y[y] * s * v2) for y in range(2 *k)]
 
 def find(lines, size, l1, l2, bounds, hough, do_something, im_h):
     a, b, c, d = [V(*a) for a in bounds]
@@ -63,7 +62,6 @@ def find(lines, size, l1, l2, bounds, hough, do_something, im_h):
     #error_surface(im_l, a, b, c, d, hough, size, v1 ,v2)
 
     grid = get_grid(a, b, c, d, hough, size)
-    dist = distance(im_l_s, grid, size)
     
     #let's try the bruteforce aproach:
     s = 0.001
@@ -75,13 +73,13 @@ def find(lines, size, l1, l2, bounds, hough, do_something, im_h):
 
     pool = multiprocessing.Pool(None)
 
-    tasks = [(X[x], Y[x], im_l_s, a, b, c, d, s, v1, v2, k, hough, size) for x in xrange(0, 2 * k)]
+    tasks = [(X[x], Y[x], im_l_s, a, b, c, d, s, 
+              v1, v2, k, hough, size) for x in xrange(0, 2 * k)]
 
     import time
     start = time.time()
     opt_ab = pool.map(job_br1, tasks, 1)
     opt_cd = pool.map(job_br2, tasks, 1)
-    an, bn, cn, dn = 4 * [0]
     d1 = 0
     for lst in opt_ab:
         for tpl in lst:
@@ -96,7 +94,8 @@ def find(lines, size, l1, l2, bounds, hough, do_something, im_h):
                 c, d = tpl[1], tpl[2]
     print time.time() - start
     grid = get_grid(a, b, c, d, hough, size) 
-    grid_lines = [[l2ad(l, size) for l in grid[0]], [l2ad(l, size) for l in grid[1]]]
+    grid_lines = [[l2ad(l, size) for l in grid[0]], 
+                  [l2ad(l, size) for l in grid[1]]]
     
     ### 
 
@@ -107,12 +106,11 @@ def find(lines, size, l1, l2, bounds, hough, do_something, im_h):
         for y in xrange(im_t.size[1]):
             im_t_l[x, y] = (im_l_l[x, y], 0, 0)
 
-    im_t_d = ImageDraw.Draw(im_t)
-
-    for l in grid[0] + grid[1]:
-        im_t_d.line(l, width=1, fill=(0, 255, 0))
+    #im_t_d = ImageDraw.Draw(im_t)
+    #for l in grid[0] + grid[1]:
+    #    im_t_d.line(l, width=1, fill=(0, 255, 0))
 
-    do_something(im_t, "lines and grid")
+    #do_something(im_t, "lines and grid")
 
 
     ###
@@ -148,5 +146,5 @@ def distance(im_l, grid, size):
     #im_g = im_g.filter(MyGaussianBlur(radius=3))
     #GaussianBlur is undocumented class, may not work in future versions of PIL
     #im_d, distance = combine(im_l, im_g)
-    distance = pcf.combine(im_l, im_g.tostring())
-    return distance
+    distance_d = pcf.combine(im_l, im_g.tostring())
+    return distance_d