X-Git-Url: http://git.tomasm.cz/imago.git/blobdiff_plain/6e16bbc7797b679d6681eee08d9103984728b98f..7f4334b61a001eb1a2df878f804a9f6771263709:/pcf.c

diff --git a/pcf.c b/pcf.c
index eccb991..cc41aa3 100644
--- a/pcf.c
+++ b/pcf.c
@@ -1,23 +1,178 @@
 #include <Python.h>
+#include <math.h>
 
-static PyObject* py_test(PyObject* self, PyObject* args)
+/* TODO delete or document this
+ *
+ */
+static PyObject* py_combine(PyObject* self, PyObject* args)
 {
-	unsigned char *image;
+	const unsigned char *im_bg;
+	const unsigned char *im_fg;
+	int size;
+
+	int i;
+	long int sum;
+	int area;
+
+	if (!PyArg_ParseTuple(args, "s#s#", &im_bg, &size, &im_fg, &size)) return NULL;
+
+	sum = 0;
+	area = 0;
+	for (i=0; i < size; i++) {
+		if (im_fg[i]){
+			sum += im_bg[i];
+			area++;
+		}
+	}
+
+	return Py_BuildValue("d", ((double) sum) / area);
+}
+
+/* Hough transform
+ *
+ * Takes dimentions of the image, the image, initial angle and TODO dt is what?.
+ * Computes Hough transform of the image. TODO size etc.
+ *
+ */
+static PyObject* py_hough(PyObject* self, PyObject* args)
+{
+	const unsigned char *image;
 	int x;
 	int y;
 	int size;
+	double init_angle;
+	double dt;
 
-	if (!PyArg_ParseTuple(args, "(ii)s#", &x, &y, &image, &size)) return NULL;
+	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;
+	// x and y are width and height of the image as ints
+	// Python sends image as (byte)string and since it is not null-terminated, must send its size
+	// init_angle and dt are doubles
 	
+
+	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;
+}
+
+/* Edge detection
+ *
+ * Takes image size, the image, and the size of TODO what?
+ */
+static PyObject* py_edge(PyObject* self, PyObject* args)
+{
+	const unsigned char *image;
+	int x;
+	int y;
+	int size;
+
 	int i;
-	for (i=0; i < size; i++) {
-		image[i] = i % 256;
+	int j;
+	int sum;
+
+	unsigned char *n_image;
+	PyObject *result;
+
+	if (!PyArg_ParseTuple(args, "(ii)s#", &x, &y, &image, &size)) return NULL;
+	// x and y are width and height of the image as ints
+	// Python sends image as (byte)string and since it is not null-terminated, must send its size
+
+	n_image = (char*) malloc(size);
+	for (i=0; i < 2 * x; i++) {
+		n_image[i] = 0;
+		n_image[(y - 2) * x + i] = 0;
+	}
+	for (i=0; i < y; i++) {
+		n_image[x * i] = 0;
+		n_image[x * i + 1] = 0;
+		n_image[x * i + x - 2] = 0;
+		n_image[x * i + x - 1] = 0;
+	}
+
+
+
+	for (i=2; i < x - 2; i++) {
+		for (j=2; j < y - 2; j++) {
+			sum = image[x * j + i - 2] + image[x * j + i - 1] + image[x * j + i + 1] + image[x * j + i + 2] + 
+				image[x * (j - 2) + i - 2] + image[x * (j - 2) + i - 1] + image[x * (j - 2) + i] + 
+				image[x * (j - 2) + i + 1] + image[x * (j - 2) + i + 2] + 
+				image[x * (j - 1) + i - 2] + image[x * (j - 1) + i - 1] + image[x * (j - 1) + i] + 
+				image[x * (j - 1) + i + 1] + image[x * (j - 1) + i + 2] +
+				image[x * (j + 2) + i - 2] + image[x * (j + 2) + i - 1] + image[x * (j + 2) + i] + 
+				image[x * (j + 2) + i + 1] + image[x * (j + 2) + i + 2] +
+				image[x * (j + 1) + i - 2] + image[x * (j + 1) + i - 1] + image[x * (j + 1) + i] + 
+				image[x * (j + 1) + i + 1] + image[x * (j + 1) + i + 2] 
+				- (24 * image[x * j + i]);
+			if (sum < 0) sum = 0;
+			if (sum > 255) sum = 255;
+			n_image[x * j + i] = sum;
+		}
 	}
 
-	return Py_BuildValue("s#", image, size);
+
+
+	result = Py_BuildValue("s#", n_image, size);
+	free(n_image);
+	return result;
 }
+
+
 static PyMethodDef myModule_methods[] = {
-	{"test", py_test, METH_VARARGS},
+	{"combine", py_combine, METH_VARARGS},
+	{"edge", py_edge, METH_VARARGS},
+	{"hough", py_hough, METH_VARARGS},
 	{NULL, NULL}
 };