better grid optimization

[imago.git] / pcf.c

diff --git a/pcf.c b/pcf.c
index eccb991..1682dbb 100644 (file)
--- a/pcf.c
+++ b/pcf.c
@@ -1,23 +1,160 @@
 #include <Python.h>
 #include <Python.h>

+#include <math.h>

 
 

-static PyObject* py_test(PyObject* self, PyObject* args)
+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);
+}
+
+static PyObject* py_hough(PyObject* self, PyObject* args)
+{
+       const unsigned char *image;

        int x;
        int y;
        int size;
        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;

        
        

+
+       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)
+{
+       const unsigned char *image;
+       int x;
+       int y;
+       int size;
+

        int i;
        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;
+
+       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[] = {
 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}
 };
 
        {NULL, NULL}
 };