image = image.filter(ImageFilter.GaussianBlur())
# GaussianBlur is undocumented class, it might not work in future versions
# of PIL
- image = Image.fromstring('L', image.size, pcf.edge(image.size, image.tostring()))
+ image = Image.fromstring('L', image.size,
+ pcf.edge(image.size, image.tostring()))
return image
def peaks(image):
c += 1
new_image_l[int(round(float(x_c)/c)), int(round(float(y_c)/c))] = 255
-
return new_image
"""Hough transform module."""
-from math import sin, cos, pi
+from math import pi
from PIL import Image
import pcf
class Hough:
- def __init__(self, size):
+ def __init__(self, size, dt, init_angle, image):
self.size = size
- self.dt = pi / size[1]
- self.initial_angle = (pi / 4) + (self.dt / 2)
-
- def transform(self, image):
- image_s = pcf.hough(image.size, image.tostring(), self.initial_angle, self.dt)
- image = Image.fromstring('L', image.size, image_s)
- return image
+ self.dt = dt
+ self.initial_angle = init_angle
+ self.image = image
+
+ @classmethod
+ def Transform(cls, image):
+ size = image.size
+ dt = pi / size[1]
+ initial_angle = (pi / 4) + (dt / 2)
+ image_s = pcf.hough(size, image.tostring(), initial_angle, dt)
+ image_t = Image.fromstring('L', size, image_s)
+ return cls(size, dt, initial_angle, image_t)
+
+ def apply_filter(self, filter_f):
+ return Hough(self.size, self.dt, self.initial_angle,
+ filter_f(self.image))
def lines_from_list(self, p_list):
lines = []
lines.append(self.angle_distance(p))
return lines
- def all_lines_h(self, image):
- im_l = image.load()
+ def all_lines_h(self):
+ im_l = self.image.load()
lines1 = []
- for x in xrange(image.size[0] / 2):
- for y in xrange(image.size[1]):
+ for x in xrange(self.size[0] / 2):
+ for y in xrange(self.size[1]):
if im_l[x, y]:
lines1.append(self.angle_distance((x, y)))
lines2 = []
- for x in xrange(image.size[0] / 2, image.size[0]):
- for y in xrange(image.size[1]):
+ for x in xrange(self.size[0] / 2, self.size[0]):
+ for y in xrange(self.size[1]):
if im_l[x, y]:
lines2.append(self.angle_distance((x, y)))
return [lines1, lines2]
- def all_lines(self, image):
- im_l = image.load()
+ def all_lines(self):
+ im_l = self.image.load()
lines = []
- for x in xrange(image.size[0]):
- for y in xrange(image.size[1]):
+ for x in xrange(self.size[0]):
+ for y in xrange(self.size[1]):
if im_l[x, y]:
lines.append(self.angle_distance((x, y)))
return lines
def angle_distance(self, point):
- return (self.dt * point[1] + self.initial_angle, point[0] - self.size[0] / 2)
+ return (self.dt * point[1] + self.initial_angle,
+ point[0] - self.size[0] / 2)
if os.path.exists(filename):
lines, l1, l2, bounds, hough = pickle.load(open(filename))
print >> sys.stderr, "using cached results"
- im_h = None
else:
- lines, l1, l2, bounds, hough, im_h = linef.find_lines(image, show_all, do_something, verbose)
+ lines, l1, l2, bounds, hough = linef.find_lines(image, show_all, do_something, verbose)
if not os.path.isdir(cache_dir):
os.makedirs(cache_dir)
d_file = open(filename, 'wb')
pickle.dump((lines, l1, l2, bounds, hough), d_file)
d_file.close()
else:
- lines, l1, l2, bounds, hough, im_h = linef.find_lines(image, show_all, do_something, verbose)
+ lines, l1, l2, bounds, hough = linef.find_lines(image, show_all, do_something, verbose)
grid, lines = gridf.find(lines, image.size, l1, l2, bounds, hough,
show_all, do_something)
"""Go image recognition lines-finding module"""
+from functools import partial
import sys
from math import sin, cos, pi
if verbose:
print >> sys.stderr, "hough transform"
- hough1 = Hough(im_h.size)
- im_hough = hough1.transform(im_h)
+ im_hough = Hough.Transform(im_h)
if show_all:
- do_something(im_hough, "hough transform")
+ do_something(im_hough.image, "hough transform")
- # im_hough = filters.peaks(im_hough)
+ # im_hough.image = filters.peaks(im_hough.image)
# if show_all:
- # do_something(im_hough, "peak extraction")
+ # do_something(im_hough.image, "peak extraction")
- im_h2 = filters.high_pass(im_hough, 96)
+ im_h2 = im_hough.apply_filter(partial(filters.high_pass, height=96))
if show_all:
- do_something(im_h2, "second high pass filters")
+ do_something(im_h2.image, "second high pass filters")
- im_h2 = filters.components2(im_h2)
+ im_h2 = im_h2.apply_filter(filters.components2)
if show_all:
- do_something(im_h2, "components centers")
+ do_something(im_h2.image, "components centers")
if verbose:
print >> sys.stderr, "second hough transform"
- hough2 = Hough(im_h2.size)
# im_hough might be used instead im_h2, but at the moment it brings a lot of
# noise to the second transform, which later confuses the center-finding
# mechanism (which is not very robust yet)
- im_hough2 = hough2.transform(im_h2)
+ im_hough2 = Hough.Transform(im_h2.image)
if show_all:
- do_something(im_hough2, "second hough transform")
+ do_something(im_hough2.image, "second hough transform")
- im_h3 = filters.high_pass(im_hough2, 120)
+ im_h3 = im_hough2.apply_filter(partial(filters.high_pass, height=120))
if show_all:
- do_something(im_h3, "third high pass filter")
+ do_something(im_h3.image, "third high pass filter")
- im_h3 = filters.components(im_h3)
+ im_h3 = im_h3.apply_filter(filters.components)
if show_all:
- do_something(im_h3, "half centers")
+ do_something(im_h3.image, "half centers")
if verbose:
print >> sys.stderr, "finding the grid"
- lines_m = hough2.all_lines_h(im_h3)
+ lines_m = im_h3.all_lines_h()
lines = []
- im_c = im_h2.convert('RGB').convert('RGB', (1, 0.5, 0.5, 0))
+ im_c = im_h2.image.convert('RGB').convert('RGB', (1, 0.5, 0.5, 0))
draw_c = ImageDraw.Draw(im_c)
bounds = []
line_points = set()
for line in line_l:
draw.line(line_from_angl_dist(line, im_h2.size), fill=255, width=7)
- draw_c.line(line_from_angl_dist(line, im_c.size), fill=(70, 70, 70), width=7)
- for p in combine(im_h2, im_line):
+ draw_c.line(line_from_angl_dist(line, im_c.size),
+ fill=(70, 70, 70), width=7)
+ for p in combine(im_h2.image, im_line):
line_points.add(p)
for point in line_points:
draw_c.point(point, fill=(120, 255, 120))
- lines.append(hough1.lines_from_list(line_points))
+ lines.append(im_hough.lines_from_list(line_points))
line_points = list(line_points)
line_points.sort()
bounds += [line_points[0], line_points[-1]]
if show_all:
do_something(image_g, "lines")
- return lines, lines_m[0][0], lines_m[1][0], bounds, hough1, im_h
+ return lines, lines_m[0][0], lines_m[1][0], bounds, im_hough
def combine(image1, image2):
im_l1 = image1.load()
import pygame
import ImageDraw
from math import sqrt, acos, copysign
+
from geometry import l2ad, line, intersection
class UserQuitError(Exception):
def display_picture(self, img):
pg_img = pygame.image.frombuffer(img.tostring(), img.size, img.mode)
- self._screen.blit(pg_img, (0,0))
+ self._screen.blit(pg_img, (0, 0))
pygame.display.flip()
def find_lines(im_orig):
projekty / imago.git / commitdiff