src/gridf2.py

   1 from math import sqrt
   2 import random
   3 import sys
   4
   5 import linef as linef
   6 import gridf as gridf
   7 from manual import lines as g_grid
   8 from geometry import l2ad
   9 import new_geometry as gm
  10
  11
  12 def plot_line(line, c):
  13     points = linef.line_from_angl_dist(line, (520, 390))
  14     pyplot.plot(*zip(*points), color=c)
  15
  16 def dst((x, y), (a, b, c)):
  17     return abs(a * x + b * y + c) / sqrt(a*a+b*b)
  18
  19 def points_to_line((x1, y1), (x2, y2)):
  20     return (y2 - y1, x1 - x2, x2 * y1 - x1 * y2)
  21
  22 def to_general(line):
  23     points = linef.line_from_angl_dist(line, (520, 390))
  24     return points_to_line(*points)
  25
  26 def nearest(lines, point):
  27     return min(map(lambda l: dst(point, l), lines))
  28
  29 def nearest2(lines, point):
  30     return min(map(lambda l: dst(point, points_to_line(*l)), lines))
  31
  32
  33 def generate_models(sgrid, lh):
  34     for f in [0, 1, 2, 3, 5, 7, 8, 11, 15, 17]:
  35         try:
  36             grid = gm.fill(sgrid[0], sgrid[1], lh , f)
  37         except ZeroDivisionError:
  38             continue
  39         grid = [sgrid[0]] + grid + [sgrid[1]]
  40         for s in xrange(17 - f):
  41             grid = [gm.expand_left(grid, lh)] + grid
  42         yield grid
  43         for i in xrange(17 - f):
  44             grid = grid[1:]
  45             grid.append(gm.expand_right(grid, lh))
  46             yield grid
  47
  48 def score(grid, lines, limit):
  49     dst = lambda (a, b, c): (a * 260 + b * 195 + c) / sqrt(a*a+b*b)
  50     dsg = lambda l: dst(points_to_line(*l))
  51     ds = map(dsg, grid)
  52     d = max(map(abs, ds))
  53     if d > limit:
  54         return 999999
  55     score = 0
  56     for line in lines:
  57         s = min(map(lambda g: abs(line[1] - g), ds))
  58         s = min(s, 2)
  59         score += s
  60
  61     return score
  62
  63 def lines2grid(lines, perp_l):
  64     b1, b2 = perp_l[0], perp_l[-1]
  65     f = lambda l: (gm.intersection(b1, l), gm.intersection(b2, l))
  66     return map(f, lines)
  67
  68 def test():
  69     import pickle
  70     import matplotlib.pyplot as pyplot
  71     import time
  72
  73     size = (520, 390)
  74     points = pickle.load(open('edges.pickle'))
  75
  76     lines = pickle.load(open('lines.pickle'))
  77
  78     r_lines = pickle.load(open('r_lines.pickle'))
  79
  80     #pyplot.scatter(*zip(*sum(r_lines, [])))
  81     #pyplot.show()
  82
  83     l1, l2 = lines
  84
  85     lines_general = map(to_general, sum(lines, []))
  86     near_points = [p for p in points if nearest(lines_general, p) <= 2]
  87
  88     while True:
  89         t0 = time.time()
  90         sc1, gridv = 999999, None
  91         for i in range(250):
  92             l1s = random.sample(l1, 2)
  93             l1s.sort(key=lambda l: l[1])
  94             sgrid = map(lambda l:linef.line_from_angl_dist(l, size), l1s)
  95             middle = lambda m: ((m, 0),(m, 390))
  96             middle = middle(gm.intersection((sgrid[0][0], sgrid[1][1]),
  97                                             (sgrid[0][1], sgrid[1][0]))[0])
  98             lh = (gm.intersection(sgrid[0], middle), gm.intersection(sgrid[1], middle))
  99             sc1_n, gridv_n = min(map(lambda g: (score(g, l1, 210), g), generate_models(sgrid, lh)))
 100             if sc1_n < sc1:
 101                 sc1, gridv = sc1_n, gridv_n
 102
 103         sc2, gridh = 999999, None
 104         for i in range(250):
 105             l2s = random.sample(l2, 2)
 106             l2s.sort(key=lambda l: l[1])
 107             sgrid = map(lambda l:linef.line_from_angl_dist(l, size), l2s)
 108             middle = lambda m: ((0, m),(520, m))
 109             middle = middle(gm.intersection((sgrid[0][0], sgrid[1][1]),
 110                                             (sgrid[0][1], sgrid[1][0]))[1])
 111             lh = (gm.intersection(sgrid[0], middle), gm.intersection(sgrid[1], middle))
 112             sc2_n, gridh_n = min(map(lambda g: (score(g, l2, 275), g), generate_models(sgrid, lh)))
 113             if sc2_n < sc2:
 114                 sc2, gridh = sc2_n, gridh_n
 115         gridv, gridh = lines2grid(gridv, gridh), lines2grid(gridh, gridv)
 116         print time.time() - t0
 117         print sc1, sc2
 118
 119         pyplot.scatter(*zip(*near_points))
 120
 121         #map(lambda l: plot_line(l, 'g'), l1 + l2)
 122         map(lambda l: pyplot.plot(*zip(*l), color='g'), gridv)
 123         map(lambda l: pyplot.plot(*zip(*l), color='g'), gridh)
 124         #plot_line(l2s[0], 'r')
 125         #plot_line(l2s[1], 'r')
 126         #plot_line(l1s[0], 'r')
 127         #plot_line(l1s[1], 'r')
 128         pyplot.xlim(0, 520)
 129         pyplot.ylim(0, 390)
 130         pyplot.show()
 131
 132 def find(lines, size, l1, l2, bounds, hough, show_all, do_something, logger):
 133     logger("finding the grid")
 134     l1, l2 = lines
 135     sc1, gridv = 999999, None
 136     for i in range(250):
 137         l1s = random.sample(l1, 2)
 138         l1s.sort(key=lambda l: l[1])
 139         sgrid = map(lambda l:linef.line_from_angl_dist(l, size), l1s)
 140         middle = lambda m: ((m, 0),(m, size[1]))
 141         middle = middle(gm.intersection((sgrid[0][0], sgrid[1][1]),
 142                                         (sgrid[0][1], sgrid[1][0]))[0])
 143         lh = (gm.intersection(sgrid[0], middle), gm.intersection(sgrid[1], middle))
 144         sc1_n, gridv_n = min(map(lambda g: (score(g, l1, size[1] / 2 + 15), g), generate_models(sgrid, lh)))
 145         if sc1_n < sc1:
 146             sc1, gridv = sc1_n, gridv_n
 147
 148     sc2, gridh = 999999, None
 149     for i in range(250):
 150         l2s = random.sample(l2, 2)
 151         l2s.sort(key=lambda l: l[1])
 152         sgrid = map(lambda l:linef.line_from_angl_dist(l, size), l2s)
 153         middle = lambda m: ((0, m),(size[0], m))
 154         middle = middle(gm.intersection((sgrid[0][0], sgrid[1][1]),
 155                                         (sgrid[0][1], sgrid[1][0]))[1])
 156         lh = (gm.intersection(sgrid[0], middle), gm.intersection(sgrid[1], middle))
 157         sc2_n, gridh_n = min(map(lambda g: (score(g, l2, size[0] / 2 + 15), g), generate_models(sgrid, lh)))
 158         if sc2_n < sc2:
 159             sc2, gridh = sc2_n, gridh_n
 160     gridv, gridh = lines2grid(gridv, gridh), lines2grid(gridh, gridv)
 161
 162     grid = [gridv, gridh]
 163     grid_lines = [[l2ad(l, size) for l in grid[0]],
 164                   [l2ad(l, size) for l in grid[1]]]
 165
 166     return grid, grid_lines