hough transform in C

diff --git a/filters.py b/filters.py
index 825834f..397a371 100644 (file)
--- a/filters.py
+++ b/filters.py
@@ -1,26 +1,13 @@
 from PIL import Image, ImageFilter
 
+import pcf
+
 def edge_detection(image):
     image = image.filter(ImageFilter.GaussianBlur())
     # GaussianBlur is undocumented class, it might not work in future versions
     # of PIL
-    image_l = image.load()
-    new_image = Image.new('L', image.size)
-    new_image_l = new_image.load()
-    
-    for x in xrange(2, image.size[0] - 2):
-        for y in xrange(2, image.size[1] - 2):
-            pix = (sum([sum([
-                image_l[a, b] 
-                    for b in range(y - 2, y + 3)]) 
-                    for a in range(x - 2, x + 3)])
-                - (25  * image_l[x, y]))
-            if pix > 255:
-                pix = 255
-            if pix < 0:
-                pix = 0 
-            new_image_l[x, y] = pix
-    return new_image
+    image = Image.fromstring('L', image.size, pcf.edge(image.size, image.tostring()))
+    return image
 
 def peaks(image):
     image_l = image.load()

diff --git a/hough.py b/hough.py
index 0e9fe2d..ec8058c 100644 (file)
--- a/hough.py
+++ b/hough.py
@@ -2,6 +2,8 @@ from math import sin, cos, pi
 
 from PIL import Image
 
+import pcf
+
 class Hough:
     def __init__(self, size):
         self.size = size
@@ -9,42 +11,9 @@ class Hough:
         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]):
-            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 of the matrix closest to the distance
-                        column = int(round(distance)) 
-                        if 0 <= 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
-
-        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
+        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 = []

diff --git a/pcf.c b/pcf.c
index 4a14681..8cb8a4b 100644 (file)
--- a/pcf.c
+++ b/pcf.c
@@ -1,4 +1,75 @@
 #include <Python.h>
+#include <math.h>
+
+static PyObject* py_hough(PyObject* self, PyObject* args)
+{
+       const unsigned char *image;
+       int x;
+       int y;
+       int size;
+       double init_angle;
+       double dt;
+
+       int i;
+       int j;
+       int a;
+
+       double distance;
+       int column;
+       int minimum;
+       int maximum;
+
+       int *matrix;
+       unsigned char *n_image;
+       PyObject *result;
+
+       if (!PyArg_ParseTuple(args, "(ii)s#dd", &x, &y, &image, &size, &init_angle, &dt)) return NULL;
+       
+
+       matrix = (int*) malloc(size * sizeof(int));
+       for (i=0; i < x * y; i++) {
+               matrix[i] = 0;
+       }
+
+
+
+       for (i=0; i < x; i++) {
+               for (j=0; j < y; j++) {
+                       if (image[j * x + i]){
+                               for (a=0; a < y; a++){
+                                       distance = (((i - x / 2) * sin((dt * a) + init_angle)) +
+                                                       ((j - y / 2) * -cos((dt * a) + init_angle)) +
+                                                       x / 2);
+                                       column = (int) round(distance);
+                                       if ((0 <= column) && (column < x)){
+                                               matrix[a * x + column]++;
+                                       }
+                               }
+                       }
+               }
+       }
+       
+
+
+
+       n_image = (char*) malloc(size * sizeof(char));
+       minimum = matrix[0];
+       maximum = matrix[0];
+       for (i=1; i < x * y; i++){
+               if (matrix[i] < minimum) minimum = matrix[i];
+               if (matrix[i] > maximum) maximum = matrix[i];
+       }
+       maximum = maximum - minimum + 1;
+       for (i=0; i < x * y; i++){
+               n_image[i] = (char) ((((float) (matrix[i] - minimum)) / maximum) * 256);
+       }
+
+       free(matrix);
+
+       result = Py_BuildValue("s#", n_image, size);
+       free(n_image);
+       return result;
+}
 
 static PyObject* py_edge(PyObject* self, PyObject* args)
 {
@@ -58,6 +129,7 @@ static PyObject* py_edge(PyObject* self, PyObject* args)
 
 static PyMethodDef myModule_methods[] = {
        {"edge", py_edge, METH_VARARGS},
+       {"hough", py_hough, METH_VARARGS},
        {NULL, NULL}
 };