pcf.c

   1 #include <Python.h>
   2 #include <math.h>
   3
   4 static PyObject* py_combine(PyObject* self, PyObject* args)
   5 {
   6         const unsigned char *im_bg;
   7         const unsigned char *im_fg;
   8         int size;
   9
  10         int i;
  11         long int sum;
  12         int area;
  13
  14         if (!PyArg_ParseTuple(args, "s#s#", &im_bg, &size, &im_fg, &size)) return NULL;
  15
  16         sum = 0;
  17         area = 0;
  18         for (i=0; i < size; i++) {
  19                 if (im_fg[i]){
  20                         sum += im_bg[i];
  21                         area++;
  22                 }
  23         }
  24
  25         return Py_BuildValue("d", ((double) sum) / area);
  26 }
  27
  28 /* Hough transform
  29  *
  30  * Takes dimentions of the image, the image, TODO size of what?, initial angle and TODO dt is what?.
  31  * Computes Hough transform of the image. TODO size etc.
  32  *
  33  */
  34 static PyObject* py_hough(PyObject* self, PyObject* args)
  35 {
  36         const unsigned char *image;
  37         int x;
  38         int y;
  39         int size;
  40         double init_angle;
  41         double dt;
  42
  43         int i;
  44         int j;
  45         int a;
  46
  47         double distance;
  48         int column;
  49         int minimum;
  50         int maximum;
  51
  52         int *matrix;
  53         unsigned char *n_image;
  54         PyObject *result;
  55
  56         if (!PyArg_ParseTuple(args, "(ii)s#dd", &x, &y, &image, &size, &init_angle, &dt)) return NULL;
  57
  58
  59         matrix = (int*) malloc(size * sizeof(int));
  60         for (i=0; i < x * y; i++) {
  61                 matrix[i] = 0;
  62         }
  63
  64
  65
  66         for (i=0; i < x; i++) {
  67                 for (j=0; j < y; j++) {
  68                         if (image[j * x + i]){
  69                                 for (a=0; a < y; a++){
  70                                         distance = (((i - x / 2) * sin((dt * a) + init_angle)) +
  71                                                         ((j - y / 2) * -cos((dt * a) + init_angle)) +
  72                                                         x / 2);
  73                                         column = (int) round(distance);
  74                                         if ((0 <= column) && (column < x)){
  75                                                 matrix[a * x + column]++;
  76                                         }
  77                                 }
  78                         }
  79                 }
  80         }
  81
  82
  83
  84
  85         n_image = (char*) malloc(size * sizeof(char));
  86         minimum = matrix[0];
  87         maximum = matrix[0];
  88         for (i=1; i < x * y; i++){
  89                 if (matrix[i] < minimum) minimum = matrix[i];
  90                 if (matrix[i] > maximum) maximum = matrix[i];
  91         }
  92         maximum = maximum - minimum + 1;
  93         for (i=0; i < x * y; i++){
  94                 n_image[i] = (char) ((((float) (matrix[i] - minimum)) / maximum) * 256);
  95         }
  96
  97         free(matrix);
  98
  99         result = Py_BuildValue("s#", n_image, size);
 100         free(n_image);
 101         return result;
 102 }
 103
 104
 105 static PyObject* py_edge(PyObject* self, PyObject* args)
 106 {
 107         const unsigned char *image;
 108         int x;
 109         int y;
 110         int size;
 111
 112         int i;
 113         int j;
 114         int sum;
 115
 116         unsigned char *n_image;
 117         PyObject *result;
 118
 119         if (!PyArg_ParseTuple(args, "(ii)s#", &x, &y, &image, &size)) return NULL;
 120
 121         n_image = (char*) malloc(size);
 122         for (i=0; i < 2 * x; i++) {
 123                 n_image[i] = 0;
 124                 n_image[(y - 2) * x + i] = 0;
 125         }
 126         for (i=0; i < y; i++) {
 127                 n_image[x * i] = 0;
 128                 n_image[x * i + 1] = 0;
 129                 n_image[x * i + x - 2] = 0;
 130                 n_image[x * i + x - 1] = 0;
 131         }
 132
 133
 134
 135         for (i=2; i < x - 2; i++) {
 136                 for (j=2; j < y - 2; j++) {
 137                         sum = image[x * j + i - 2] + image[x * j + i - 1] + image[x * j + i + 1] + image[x * j + i + 2] +
 138                                 image[x * (j - 2) + i - 2] + image[x * (j - 2) + i - 1] + image[x * (j - 2) + i] +
 139                                 image[x * (j - 2) + i + 1] + image[x * (j - 2) + i + 2] +
 140                                 image[x * (j - 1) + i - 2] + image[x * (j - 1) + i - 1] + image[x * (j - 1) + i] +
 141                                 image[x * (j - 1) + i + 1] + image[x * (j - 1) + i + 2] +
 142                                 image[x * (j + 2) + i - 2] + image[x * (j + 2) + i - 1] + image[x * (j + 2) + i] +
 143                                 image[x * (j + 2) + i + 1] + image[x * (j + 2) + i + 2] +
 144                                 image[x * (j + 1) + i - 2] + image[x * (j + 1) + i - 1] + image[x * (j + 1) + i] +
 145                                 image[x * (j + 1) + i + 1] + image[x * (j + 1) + i + 2]
 146                                 - (24 * image[x * j + i]);
 147                         if (sum < 0) sum = 0;
 148                         if (sum > 255) sum = 255;
 149                         n_image[x * j + i] = sum;
 150                 }
 151         }
 152
 153
 154
 155         result = Py_BuildValue("s#", n_image, size);
 156         free(n_image);
 157         return result;
 158 }
 159
 160
 161 static PyMethodDef myModule_methods[] = {
 162         {"combine", py_combine, METH_VARARGS},
 163         {"edge", py_edge, METH_VARARGS},
 164         {"hough", py_hough, METH_VARARGS},
 165         {NULL, NULL}
 166 };
 167
 168 void initpcf()
 169 {
 170                 (void) Py_InitModule("pcf", myModule_methods);
 171 }