From e38a85551b486a0e1691eba67a9c8cfad528dbf1 Mon Sep 17 00:00:00 2001 From: Tomas Musil Date: Fri, 19 Oct 2012 23:30:00 +0200 Subject: [PATCH 1/1] hough transform in C --- filters.py | 21 ++++-------------- hough.py | 41 +++++------------------------------ pcf.c | 72 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 81 insertions(+), 53 deletions(-) diff --git a/filters.py b/filters.py index 825834f..397a371 100644 --- 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 --- 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 --- a/pcf.c +++ b/pcf.c @@ -1,4 +1,75 @@ #include +#include + +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} }; -- 2.4.2