X-Git-Url: http://git.tomasm.cz/imago.git/blobdiff_plain/8d05ccd11445ae069ae14dfb95d566907546e989..24a7e923346be5e355a7d61e642fc469310444ef:/hough.py

diff --git a/hough.py b/hough.py
index 5fca93f..ec8058c 100644
--- a/hough.py
+++ b/hough.py
@@ -1,90 +1,49 @@
-from PIL import Image
 from math import sin, cos, pi
-from commons import clear
+
+from PIL import Image
+
+import pcf
 
 class Hough:
     def __init__(self, size):
-	self.size = size
+        self.size = size
         self.dt = pi / size[1]
         self.initial_angle = (pi / 4) + (self.dt / 2)
 
     def transform(self, image):
-        image_l = image.load()
-        size = image.size
-        
-        matrix = [[0]*size[1] for _ in xrange(size[0])]
-
-        dt = self.dt
-        initial_angle = self.initial_angle
-
-        for x in xrange(size[0]):
-            clear()
-            print "hough transform: {0:>3}/{1}".format(x + 1, size[0])
-            for y in xrange(size[1]):
-                if image_l[x, y]:
-                    # for every angle:
-                    for a in xrange(size[1]):
-                        # find the distance:
-                        # distance is the dot product of vector (x, y) - centerpoint
-                        # and a unit vector orthogonal to the angle
-                        distance = (((x - (size[0] / 2)) * sin((dt * a) + initial_angle)) + 
-                                    ((y - (size[1] / 2)) * -cos((dt * a) + initial_angle)) +
-                                    size[0] / 2)
-                        column = int(round(distance)) # column of the matrix closest to the distance
-                        if column >= 0 and column < size[0]:
-                            matrix[column][a] += 1
-
-        new_image = Image.new('L', size)
-        new_image_l = new_image.load()
-
-        minimum = min([min(m) for m in matrix])
-
-        maximum = max([max(m) for m in matrix]) - minimum
+        image_s = pcf.hough(image.size, image.tostring(), self.initial_angle, self.dt)
+        image = Image.fromstring('L', image.size, image_s)
+        return image
+
+    def lines_from_list(self, p_list):
+        lines = []
+        for p in p_list:
+            lines.append(self.angle_distance(p))
+        return lines
 
-        for y in xrange(size[1]):
-            for x in xrange(size[0]):
-                new_image_l[x, y] = (float(matrix[x][y] - minimum) / maximum) * 255
-            
-        return new_image
+    def all_lines_h(self, image):
+        im_l = image.load()
+        lines1 = []
+        for x in xrange(image.size[0] / 2):
+            for y in xrange(image.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]):
+                if im_l[x, y]:
+                    lines2.append(self.angle_distance((x, y)))
+        return [lines1, lines2]
 
     def all_lines(self, image):
-	im_l = image.load()
-	lines = []
-	for x in xrange(image.size[0]):
+        im_l = image.load()
+        lines = []
+        for x in xrange(image.size[0]):
             for y in xrange(image.size[1]):
-		if im_l[x, y]:
-		    lines.append(self.angle_distance((x, y)))
+                if im_l[x, y]:
+                    lines.append(self.angle_distance((x, y)))
         return lines
     
-    def find_angle_distance(self, image):
-        image_l = image.load()
-
-        points = []
-
-        count = 0
-        point_x = 0
-        point_y = 0
-        for x in xrange(image.size[0] / 2):
-            for y in xrange(image.size[1] / 2, image.size[1]):
-                if image_l[x, y]:
-                    count += 1
-                    point_x += x
-                    point_y += y
-        points.append((float(point_x) / count, float(point_y) / count))
-
-        count = 0
-        point_x = 0
-        point_y = 0
-        for x in xrange(image.size[0] / 2, image.size[0]):
-            for y in xrange(image.size[1] / 2, image.size[1]):
-                if image_l[x, y]:
-                    count += 1
-                    point_x += x
-                    point_y += y
-        points.append((float(point_x) / count, float(point_y) / count))
-
-        return [self.angle_distance(p) for p in points]
-
     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)
+